Leetcode 1019

Author: Kondareddy1209

Leetcode/Leetcode1019.py

@@ -0,0 +1,146 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+
+class Solution:
+    def nextLargerNodes(self, head: Optional[ListNode]) -> List[int]:
+
+        # ----------------------------------------------------------
+        # Step 1: Convert Linked List to Array
+        # Example:
+        # Linked List : 2 -> 7 -> 4 -> 3 -> 5
+        # Array       : [2, 7, 4, 3, 5]
+        # ----------------------------------------------------------
+        nums = []
+        curr = head
+
+        while curr:
+            nums.append(curr.val)
+            curr = curr.next
+
+        # ==========================================================
+        # APPROACH 1 : BRUTE FORCE
+        # ----------------------------------------------------------
+        # How it works:
+        # For every element, search all elements on its right.
+        # The first greater element becomes the answer.
+        #
+        # Example:
+        # nums = [2,7,4,3,5]
+        #
+        # 2 -> first greater = 7
+        # 7 -> no greater = 0
+        # 4 -> first greater = 5
+        # 3 -> first greater = 5
+        # 5 -> no greater = 0
+        #
+        # Time Complexity : O(n²)
+        # Space Complexity: O(n)
+        # ==========================================================
+
+        """
+        ans = [0] * len(nums)
+
+        i = 0
+        while i < len(nums):
+
+            j = i + 1
+
+            while j < len(nums):
+
+                if nums[j] > nums[i]:
+                    ans[i] = nums[j]
+                    break
+
+                j += 1
+
+            i += 1
+
+        return ans
+        """
+
+        # ==========================================================
+        # APPROACH 2 : MONOTONIC STACK (OPTIMAL)
+        #
+        # How it works:
+        #
+        # The stack stores INDICES of elements whose next greater
+        # element has NOT been found yet.
+        #
+        # Whenever a larger value arrives:
+        #
+        #   1. Compare it with the top of the stack.
+        #   2. If current value is larger,
+        #      pop the index.
+        #   3. Current value becomes the answer
+        #      for the popped index.
+        #   4. Keep popping while current value
+        #      is larger than the stack top.
+        #   5. Finally push the current index.
+        #
+        # Example:
+        #
+        # nums = [2,7,4,3,5]
+        #
+        # i=0 (2)
+        # stack = [0]
+        #
+        # i=1 (7)
+        # 7 > 2
+        # pop 0
+        # ans[0]=7
+        # stack=[1]
+        #
+        # i=2 (4)
+        # 4 < 7
+        # stack=[1,2]
+        #
+        # i=3 (3)
+        # 3 < 4
+        # stack=[1,2,3]
+        #
+        # i=4 (5)
+        # 5 > 3
+        # pop 3
+        # ans[3]=5
+        #
+        # 5 > 4
+        # pop 2
+        # ans[2]=5
+        #
+        # 5 < 7
+        # stop
+        #
+        # push 4
+        # stack=[1,4]
+        #
+        # Final Answer:
+        # [7,0,5,5,0]
+        #
+        # Time Complexity : O(n)
+        # Space Complexity: O(n)
+        #
+        # Why O(n)?
+        # - Every index is pushed exactly once.
+        # - Every index is popped at most once.
+        # - Total stack operations = 2n.
+        # - Therefore overall complexity is O(n).
+        # ==========================================================
+
+        ans = [0] * len(nums)
+        stack = []      # Stores indices
+
+        for i in range(len(nums)):
+
+            # Current element is greater than elements
+            # waiting inside the stack.
+            while stack and nums[i] > nums[stack[-1]]:
+                idx = stack.pop()
+                ans[idx] = nums[i]
+
+            # Current index waits for its next greater element.
+            stack.append(i)
+
+        return ans