Update Commit

Author: NR7KINGithub

13. Stack And Queue/496_Next_Greater_Element_I.py

@@ -0,0 +1,15 @@
+from typing import List
+
+def nextGreaterElement(nums1: List[int], nums2: List[int]) -> List[int]:
+    next_greater = {}
+    stack = []
+    for num  in nums2:
+        while stack and stack[-1] < num:
+            next_greater[stack.pop()] = num
+        stack.append(num)
+    while stack:
+        next_greater[stack.pop()] = -1
+    return [next_greater[num] for num in nums1]   
+
+if __name__ == "__main__":
+    print(nextGreaterElement([4,1,2], [1,3,4,2]))

18. Binary Tree Part II/102_Binary_Tree_Level_Order_Traversal.py

@@ -0,0 +1,41 @@
+from collections import deque
+from typing import List, Optional 
+
+class Node:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+class Solution:
+    def levelOrder(self, root: Optional[Node]) -> List[List[int]]:
+        if not root:
+            return []
+        result = []
+        queue = deque([root])
+
+        while queue:
+            level_size = len(queue)
+            current_level = []
+
+            for _ in range(level_size):
+                node = queue.popleft()
+                current_level.append(node.val)
+
+                if node.left:
+                    queue.append(node.left)
+                
+                if node.right:
+                    queue.append(node.right)
+            result.append(current_level)
+
+        return result
+    
+if __name__ == "__main__":
+    root = Node(3)
+    root.left = Node(9)
+    root.right = Node(20)
+    root.right.left = Node(15)
+    root.right.right = Node(7)
+
+    print(Solution().levelOrder(root))

18. Binary Tree Part II/103_Binary_Tree_Zigzag_Level_Order_Traversal.py

@@ -0,0 +1,47 @@
+from collections import deque
+from typing import List, Optional 
+
+class Node:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+class Solution:
+    def levelOrder(self, root: Optional[Node]) -> List[List[int]]:
+        if not root:
+            return []
+        result = []
+        queue = deque([root])
+        left_to_right = True
+
+        while queue:
+            level_size = len(queue)
+            current_level = []
+
+            for _ in range(level_size):
+                node = queue.popleft()
+                current_level.append(node.val)
+
+                if node.left:
+                    queue.append(node.left)
+                
+                if node.right:
+                    queue.append(node.right)
+
+            if not left_to_right:
+                    current_level.reverse()
+
+            result.append(current_level)
+            left_to_right = not left_to_right
+
+        return result
+    
+if __name__ == "__main__":
+    root = Node(3)
+    root.left = Node(9)
+    root.right = Node(20)
+    root.right.left = Node(15)
+    root.right.right = Node(7)
+
+    print(Solution().levelOrder(root))

21. Binary Search Tree Part II/230_Kth_Smallest_Element_In_A_BST.py

@@ -0,0 +1,35 @@
+# Definition for a binary tree node.
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+class Solution:
+    def kthSmallest(self, root: TreeNode, k: int) -> int:
+        # Initialize variables to keep track of count and result
+        self.count = 0
+        self.result = None
+        # Helper function for in-order traversal
+        def in_order_traversal(node):
+            if not node or self.result is not None:
+                return   
+            # Traverse the left subtree
+            in_order_traversal(node.left)
+            # Process the current node
+            self.count += 1
+            if self.count == k:
+                self.result = node.val
+                return
+            # Traverse the right subtree
+            in_order_traversal(node.right)
+        # Perform the in-order traversal
+        in_order_traversal(root)
+        return self.result
+    
+if __name__ == "__main__":
+    root = TreeNode(3)
+    root.left = TreeNode(1)
+    root.right = TreeNode(4)
+    root.left.right = TreeNode(2)
+    print(Solution().kthSmallest(root, 1))

22. Binary Trees [Miscellaneous]/703_Kth_Largest_Element_In_A_Stream.py

@@ -0,0 +1,24 @@
+import heapq
+from typing import List
+
+class KthLargest:
+
+    def __init__(self, k: int, nums: List[int]):
+        self.k = k
+        self.minheap = nums
+        heapq.heapify(self.minheap)
+        while len(self.minheap) > k:
+            heapq.heappop(self.minheap)
+    def add(self, val: int) -> int:
+        heapq.heappush(self.minheap, val)
+        if len(self.minheap) > self.k:
+            heapq.heappop(self.minheap)
+        return self.minheap[0]
+
+if __name__ == "__main__":
+    kth_largest = KthLargest(3, [4, 5, 8, 2])
+    print(kth_largest.add(3))  
+    print(kth_largest.add(5))  
+    print(kth_largest.add(10)) 
+    print(kth_largest.add(9))  
+    print(kth_largest.add(4))