added stack programs

Programs/6_Stack&Queues/10_Previous_Greater_Element.py

@@ -0,0 +1,34 @@
+# NA , Easy
+
+# Optimal
+# T.C. - O(N)
+# S.C  - O(N)
+
+
+class Solution:
+    def previous_greater_element(self, ls, out):
+        # Monotonically Decreasing Stack from bottom to top
+        stk = []
+        ans = [-1 for _ in range(len(ls))]
+
+        for idx in range(len(ls)):
+            while stk and stk[-1] <= ls[idx]:
+                stk.pop(-1)
+
+            ans[idx] = stk[-1] if stk else -1
+            stk.append(ls[idx])
+
+        return ans == out, ans
+
+
+# ls = [10, 4, 2, 20, 40, 12, 30]
+# out = [-1, 10, 4, -1, -1, 40, 40]
+
+# ls = [10, 20, 30, 40]
+# out = [-1, -1, -1, -1]
+
+# ls = [40, 30, 20, 10]
+# out = [-1, 40, 30, 20]
+
+obj = Solution()
+print(obj.previous_greater_element(ls, out))

Programs/6_Stack&Queues/11_Next_Greates_Element.py

@@ -0,0 +1,28 @@
+# https://www.geeksforgeeks.org/problems/greater-on-right-side4305/1 , Easy
+
+# Optimal
+# T.C. - O(N)
+# S.C  - O(N)
+
+
+class Solution:
+    def nextLargerElement(self, arr, n):
+        # Monotonically Decreasing Stack from bottom to top
+        stk = []
+        ans = [-1 for _ in range(len(arr))]
+
+        for idx in range(len(arr) - 1, -1, -1):
+            while stk and stk[-1] <= arr[idx]:
+                stk.pop(-1)
+
+            ans[idx] = stk[-1] if stk else -1
+            stk.append(arr[idx])
+
+        return ans
+
+
+arr = [16, 17, 4, 3, 5, 2]
+arr = [2, 3, 1, 9]
+arr = [1, 3, 2, 4]
+obj = Solution()
+print(obj.nextGreatest(arr, len(arr)))

Programs/6_Stack&Queues/1_Implement_Stack_using_Arrays.py

@@ -0,0 +1,75 @@
+# NA , Easy
+
+
+# Optimal
+# T.C. - O(1) [push,pop,peek]
+# S.C  - O(cap)
+
+
+class MyStack:
+
+    def __init__(self, cap):
+        self.capacity = cap
+        self.arr = [None] * self.capacity
+        self.top = -1
+
+    # Function to push an integer into the stack.
+    def push(self, data):
+        if self.isFull():
+            return "Stack is Full!"
+
+        self.top += 1
+        self.arr[self.top] = data
+        return self.printStack()
+
+    # Function to remove an item from top of the stack.
+    def pop(self):
+        if self.isEmpty():
+            return "Stack is Empty!"
+        else:
+            removedData = self.arr[self.top]
+            self.top -= 1
+            return self.printStack(), f"Removed: {removedData}"
+
+    # Check Stack Empty
+    def isEmpty(self) -> bool:
+        return self.top == -1
+
+    # Check Stack Full
+    def isFull(self) -> bool:
+        return self.top == len(self.arr) - 1
+
+    # Get Stack top element
+    def peek(self) -> int:
+        if self.top != -1:
+            return self.arr[self.top]
+        else:
+            return -1
+
+    def printStack(self) -> list[int]:
+        ls = []
+        for i in range(0, self.top + 1):
+            ls.append(self.arr[i])
+        return ls
+
+
+obj = MyStack(5)
+print(obj.push(1))
+print(obj.push(2))
+print(obj.push(3))
+print(obj.pop())
+print(obj.pop())
+print(obj.push(4))
+print(obj.push(4))
+print(obj.push(4))
+print(obj.push(4))
+print(obj.pop())
+print(obj.pop())
+print(obj.pop())
+print(obj.pop())
+print(obj.pop())
+print(obj.pop())
+print(obj.push(4))
+print(obj.push(6))
+print(obj.push(7))
+print(obj.peek())

Programs/6_Stack&Queues/2_Implement_Queue_Using_Array.py

@@ -0,0 +1,79 @@
+# NA , Easy
+
+# Optimal
+# T.C. - O(1) [push,pop,top] [We cannot insert elements in the front of the queue even we have some free space left in the front of the queue]
+# S.C  - O(cap)
+
+
+class MyQueue:
+
+    def __init__(self, cap) -> None:
+        self.cap = cap
+        self.arr = [None] * self.cap
+        self.rear = -1
+        self.front = -1
+
+    # Function to push an element x in a queue.
+    def enqueue(self, x):
+        if self.isFull():
+            return "Queue is Full!"
+
+        self.rear += 1
+        self.arr[self.rear] = x
+        return self.printQueue()
+
+    # Function to pop an element from queue and return that element.
+    def dequeue(self):
+        if self.isEmpty():
+            return "Queue is Empty!"
+
+        self.front += 1
+        removedData = self.arr[self.front]
+        return self.printQueue(), f"Removed: {removedData}"
+
+    # Function to get the front element
+    def peek(self):
+        if not self.isEmpty():
+            return self.arr[self.front + 1]
+        else:
+            return -1
+
+    # Function to get the rear-end element
+    def _rear(self):
+        if not self.isEmpty():
+            return self.arr[self.rear]
+        else:
+            return -1
+
+    # Function to check queue full
+    def isFull(self):
+        return self.rear == self.cap - 1
+
+    # Function to check queue empty
+    def isEmpty(self):
+        return self.front == self.rear
+
+    # Print Queue
+    def printQueue(self) -> list[int]:
+        ls = []
+        for i in range(self.front + 1, self.rear + 1):
+            ls.append(self.arr[i])
+        return ls
+
+
+obj = MyQueue(5)
+print(obj.enqueue(1))
+print(obj.enqueue(2))
+print(obj.enqueue(3))
+print(obj.enqueue(4))
+print(obj._rear())
+print(obj.peek())
+print(obj.enqueue(5))
+print(obj.enqueue(6))
+print(obj.dequeue())
+print(obj.dequeue())
+print(obj.dequeue())
+print(obj.dequeue())
+print(obj.dequeue())
+print(obj.enqueue(6))
+print(obj.enqueue(7))

Programs/6_Stack&Queues/3_Implement_Circular_Queue_using_Array.py

@@ -0,0 +1,80 @@
+# NA , Easy
+
+# Optimal
+# T.C. - O(1) [push,pop,top] [Unlike normal queue we cant add more elemnts in the front of the queue if there are is any space left]
+# S.C  - O(maxCapacity)
+
+
+class MyCircularQueue:
+
+    def __init__(self, maxCapacity) -> None:
+        self.maxCapacity = maxCapacity
+        self.arr = [None] * self.maxCapacity
+        self.rear = -1
+        self.front = -1
+        self.currSize = 0
+
+    # Function to push an element x in a queue.
+    def enqueue(self, x):
+        if self.isFull():
+            return "Queue is full!"
+
+        self.arr[(self.rear + 1) % self.maxCapacity] = x
+        self.rear += 1
+        self.currSize += 1
+        return self.arr
+
+    # Function to pop an element from queue and return that element.
+    def dequeue(self):
+        if self.isEmpty():
+            return "Queue is empty!"
+
+        self.arr[(self.front + 1) % self.maxCapacity] = None
+        self.front += 1
+        self.currSize -= 1
+        return self.arr
+
+    # Function to get the front element
+    def peek(self):
+        if not self.isEmpty():
+            return self.arr[(self.front + 1) % self.maxCapacity]
+        else:
+            return -1
+
+    # Function to get the rear-end element
+    def _rear(self):
+        if not self.isEmpty():
+            return self.arr[self.rear % self.maxCapacity]
+        else:
+            return -1
+
+    # Function to check queue full
+    def isFull(self):
+        return self.currSize == self.maxCapacity
+
+    # Function to check queue empty
+    def isEmpty(self):
+        return self.currSize == 0
+
+
+obj = MyCircularQueue(5)
+print(obj.enqueue(1))
+print(obj.enqueue(2))
+print(obj.enqueue(3))
+print(obj.enqueue(4))
+print(obj.enqueue(5))
+print(obj.enqueue(1))
+print(obj.enqueue(6))
+print(obj.dequeue())
+print(obj.dequeue())
+print(obj.enqueue(6))
+print(obj.dequeue())
+print(obj.dequeue())
+print(obj.dequeue())
+print(obj.dequeue())
+print(obj.dequeue())
+print(obj.enqueue(7))
+print(obj.enqueue(8))
+print(obj.enqueue(8))
+print(obj.peek())
+print(obj._rear())

Programs/6_Stack&Queues/4_Implement Stack using Queues.py

@@ -0,0 +1,30 @@
+# https://leetcode.com/problems/implement-queue-using-stacks/ , Easy
+
+# Optimal
+# T.C. - [push O(1),pop O(n),peek O(1),empty O(1)]
+# S.C  - O(1)
+
+
+from collections import deque
+
+
+class MyStack:
+
+    def __init__(self):
+        self.q = deque([])
+
+    def push(self, x: int) -> None:
+        self.q.append(x)
+
+    def pop(self) -> int:
+        for i in range(len(self.q) - 1):
+            data = self.q.popleft()
+            self.q.append(data)
+
+        return self.q.popleft()
+
+    def top(self) -> int:
+        return self.q[-1]
+
+    def empty(self) -> bool:
+        return len(self.q) == 0