Stack Sliding Window

Author: shreymehul

239.MaxSlidingWindow.cs

@@ -0,0 +1,81 @@
+// 239. Sliding Window Maximum
+
+// You are given an array of integers nums, there is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves right by one position.
+
+// Return the max sliding window.
+
+
+//c# incomplete solution.
+//need deque implementation
+public class Solution {
+    public int[] MaxSlidingWindow(int[] nums, int k) {
+        int[] res = new int[nums.Length-k+1];
+        Deque<int> max = new Deque<int>();
+        for (int i = 0; i < k; i++)
+        {
+            if (max.Count > 0 && max.PeekFirst() < nums[i])
+            {
+                max.Clear();
+            }
+            max.AddFirst(nums[i]);
+        }
+        res[0] = max.PeekFirst();
+        for (int i = k; i < nums.Length; i++)
+        {
+            if (max.Count > 0 && max.PeekFirst() == nums[i-k])
+                max.PopFirst();
+            if (max.Count > 0 && max.Peek() < nums[i])
+            {
+                max.Clear();
+            }
+            while(max.Count > 0 && max.PeekLast > nums[i])
+                max.PopLast();
+            max.Enqueue(nums[i]);
+            res[i-k+1] = max.PeekFirst();
+        }
+        return res;
+    }
+}
+
+
+////c++ dequeue soln
+vector<int> maxSlidingWindow(vector<int>& nums, int k) {
+    
+    vector <int> ans;
+    
+    deque<int> dq;
+    
+    int i=0,j=0;
+    
+    while(j<nums.size())
+    {
+        while(!dq.empty() && dq.back()<nums[j])
+        {
+            dq.pop_back();  //coz we dont need elemnt lesser than it in front of queue 
+            // to better understanding dry run on nums={1,3,1,2,0,5} & k=3
+        }
+        
+        dq.push_back(nums[j]);
+        
+        //if window size not achieved
+        if(j-i+1<k)
+        {
+            j++;
+        }
+        else
+        {
+           
+            ans.push_back(dq.front());
+            
+            //calculation for i
+            if(nums[i]==dq.front())
+            {
+                dq.pop_front();
+            }
+            
+            i++;
+            j++;
+        }
+    }
+    
+    return ans;

42.Trap.cs

@@ -0,0 +1,28 @@
+// 42. Trapping Rain Water
+
+// Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it can trap after raining.
+ 
+// Example :
+// Input: height = [0,1,0,2,1,0,1,3,2,1,2,1]
+// Output: 6
+// Explanation: The above elevation map (black section) is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped.
+
+public class Solution {
+    public int Trap(int[] height) {
+        int[] maxleft = new int[height.Length];
+        int[] maxright = new int[height.Length];
+        int res = 0;
+        maxleft[0] = height[0];
+        maxright[height.Length-1] = height[height.Length-1];
+        for(int i=1;i<height.Length;i++){
+            maxleft[i] = Math.Max(maxleft[i-1],height[i]);
+        }
+        for(int i=height.Length-2;i>=0;i--){
+            maxright[i] = Math.Max(maxright[i+1],height[i]);
+        }
+        for(int i=0;i<height.Length;i++){
+            res += Math.Min(maxleft[i],maxright[i]) - height[i];
+        }
+        return res;
+    }
+}

496.NextGreaterElement.cs

@@ -0,0 +1,33 @@
+// 496. Next Greater Element I
+
+// The next greater element of some element x in an array is the first greater element that is to the right of x in the same array.
+
+// You are given two distinct 0-indexed integer arrays nums1 and nums2, where nums1 is a subset of nums2.
+
+// For each 0 <= i < nums1.length, find the index j such that nums1[i] == nums2[j] and determine the next greater element of nums2[j] in nums2. If there is no next greater element, then the answer for this query is -1.
+
+// Return an array ans of length nums1.length such that ans[i] is the next greater element as described above.
+
+
+public class Solution {
+    public int[] NextGreaterElement(int[] nums1, int[] nums2)
+    {
+        Dictionary<int, int> Map = new Dictionary<int, int>();
+
+        Stack<int> st = new Stack<int>();
+        for (int i = 0; i < nums2.Length; i++)
+        {
+            while (st.Count > 0 && st.Peek() < nums2[i])
+            {
+                Map.Add(st.Pop(), nums2[i]);
+            }
+            st.Push(nums2[i]);
+        }
+        int[] res = new int[nums1.Length];
+        for (int i = 0; i < nums1.Length; i++)
+        {
+            res[i] = Map.GetValueOrDefault(nums1[i], -1);
+        }
+        return res;
+    }
+}