add monotonic stack pattern

Author: ashishps1

patterns/c#/MonotonicStack.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+
+public class MonotonicStack {
+    public int[] NextGreaterElement(int[] nums) {
+        int n = nums.Length;
+        int[] result = new int[n];
+        Array.Fill(result, -1); // Default to -1 if no greater element exists
+        Stack<int> stack = new Stack<int>(); // Stack stores indices
+
+        for (int i = 0; i < n; i++) {
+            while (stack.Count > 0 && nums[i] > nums[stack.Peek()]) {
+                int index = stack.Pop();
+                result[index] = nums[i];
+            }
+            stack.Push(i);
+        }
+        return result;
+    }
+
+    public int[] DailyTemperatures(int[] temperatures) {
+        int n = temperatures.Length;
+        int[] result = new int[n]; // Result array initialized with 0s
+        Stack<int> stack = new Stack<int>(); // Monotonic decreasing stack
+
+        for (int i = 0; i < n; i++) {
+            while (stack.Count > 0 && temperatures[i] > temperatures[stack.Peek()]) {
+                int prevIndex = stack.Pop();
+                result[prevIndex] = i - prevIndex;
+            }
+            stack.Push(i);
+        }
+        return result;
+    }
+}

patterns/c++/KadaneAlgorithm.cpp

@@ -0,0 +1,19 @@
+#include <vector>
+#include <algorithm> // For std::max
+
+class KadaneAlgorithm {
+public:
+    int maxSubArray(std::vector<int>& nums) {
+        int currentSum = nums[0]; // Start with the first element
+        int maxSum = nums[0];     // Initialize maxSum with the first element
+
+        // Traverse the array from the second element
+        for (size_t i = 1; i < nums.size(); i++) {
+            // If currentSum is negative, reset to current element
+            currentSum = std::max(nums[i], currentSum + nums[i]);
+            // Update maxSum if currentSum is greater
+            maxSum = std::max(maxSum, currentSum);
+        }
+        return maxSum;
+    }
+};

patterns/c++/MonotonicStack.cpp

@@ -0,0 +1,39 @@
+#include <vector>
+#include <stack>
+
+using namespace std;
+
+class MonotonicStack {
+public:
+    vector<int> nextGreaterElement(vector<int>& nums) {
+        int n = nums.size();
+        vector<int> result(n, -1); // Default to -1 if no greater element exists
+        stack<int> stack; // Stack stores indices
+
+        for (int i = 0; i < n; i++) {
+            while (!stack.empty() && nums[i] > nums[stack.top()]) {
+                int index = stack.top();
+                stack.pop();
+                result[index] = nums[i];
+            }
+            stack.push(i);
+        }
+        return result;
+    }
+
+    vector<int> dailyTemperatures(vector<int>& temperatures) {
+        int n = temperatures.size();
+        vector<int> result(n, 0);
+        stack<int> stack; // Monotonic decreasing stack
+
+        for (int i = 0; i < n; i++) {
+            while (!stack.empty() && temperatures[i] > temperatures[stack.top()]) {
+                int prevIndex = stack.top();
+                stack.pop();
+                result[prevIndex] = i - prevIndex;
+            }
+            stack.push(i);
+        }
+        return result;
+    }
+};

patterns/go/monotonic_stack.go

@@ -0,0 +1,46 @@
+package main
+
+import "fmt"
+
+func nextGreaterElement(nums []int) []int {
+	n := len(nums)
+	result := make([]int, n)
+	for i := range result {
+		result[i] = -1 // Default to -1 if no greater element exists
+	}
+	stack := []int{} // Stack stores indices
+
+	for i := 0; i < n; i++ {
+		for len(stack) > 0 && nums[i] > nums[stack[len(stack)-1]] {
+			index := stack[len(stack)-1]
+			stack = stack[:len(stack)-1]
+			result[index] = nums[i]
+		}
+		stack = append(stack, i)
+	}
+	return result
+}
+
+func dailyTemperatures(temperatures []int) []int {
+	n := len(temperatures)
+	result := make([]int, n) // Result array initialized with 0s
+	stack := []int{}         // Monotonic decreasing stack
+
+	for i := 0; i < n; i++ {
+		for len(stack) > 0 && temperatures[i] > temperatures[stack[len(stack)-1]] {
+			prevIndex := stack[len(stack)-1]
+			stack = stack[:len(stack)-1]
+			result[prevIndex] = i - prevIndex
+		}
+		stack = append(stack, i)
+	}
+	return result
+}
+
+func main() {
+	nums := []int{2, 1, 5, 6, 2, 3}
+	fmt.Println(nextGreaterElement(nums))
+
+	temperatures := []int{73, 74, 75, 71, 69, 72, 76, 73}
+	fmt.Println(dailyTemperatures(temperatures))
+}

patterns/java/MonotonicStack.java

@@ -0,0 +1,43 @@
+package patterns.java;
+
+import java.util.Arrays;
+import java.util.Stack;
+
+public class MonotonicStack {
+
+    public int[] nextGreaterElement(int[] nums) {
+        int n = nums.length;
+        int[] result = new int[n]; // Output array
+        Arrays.fill(result, -1); // Default to -1 if no greater element exists
+        Stack<Integer> stack = new Stack<>(); // Stack stores indices
+
+        // Iterate through the array
+        for (int i = 0; i < n; i++) {
+            // While stack is not empty and current element is greater than stack top
+            while (!stack.isEmpty() && nums[i] > nums[stack.peek()]) {
+                int index = stack.pop(); // Pop the top element
+                result[index] = nums[i]; // The current element is the Next Greater Element
+            }
+            stack.push(i); // Push the current index onto the stack
+        }
+        return result;
+    }
+
+    public int[] dailyTemperatures(int[] temperatures) {
+        int n = temperatures.length;
+        int[] result = new int[n]; // Result array initialized with 0s
+        Stack<Integer> stack = new Stack<>(); // Monotonic decreasing stack (stores indices)
+
+        // Iterate through the temperature array
+        for (int i = 0; i < n; i++) {
+            // While stack is not empty AND the current temperature is warmer than the temperature at stack top
+            while (!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]) {
+                int prevIndex = stack.pop(); // Pop the previous day's index
+                result[prevIndex] = i - prevIndex; // Calculate the wait time
+            }
+            stack.push(i); // Push current index onto the stack
+        }
+
+        return result; // Return the computed results
+    }    
+}

patterns/javascript/monotonicStack.js

@@ -0,0 +1,31 @@
+class MonotonicStack {
+    nextGreaterElement(nums) {
+        let n = nums.length;
+        let result = new Array(n).fill(-1); // Default to -1 if no greater element exists
+        let stack = []; // Stack stores indices
+
+        for (let i = 0; i < n; i++) {
+            while (stack.length > 0 && nums[i] > nums[stack[stack.length - 1]]) {
+                let index = stack.pop();
+                result[index] = nums[i];
+            }
+            stack.push(i);
+        }
+        return result;
+    }
+
+    dailyTemperatures(temperatures) {
+        let n = temperatures.length;
+        let result = new Array(n).fill(0); // Result array initialized with 0s
+        let stack = []; // Monotonic decreasing stack
+
+        for (let i = 0; i < n; i++) {
+            while (stack.length > 0 && temperatures[i] > temperatures[stack[stack.length - 1]]) {
+                let prevIndex = stack.pop();
+                result[prevIndex] = i - prevIndex;
+            }
+            stack.push(i);
+        }
+        return result;
+    }
+}

patterns/python/monotonic_stack.py

@@ -0,0 +1,26 @@
+class MonotonicStack:
+    def next_greater_element(self, nums):
+        n = len(nums)
+        result = [-1] * n  # Default to -1 if no greater element exists
+        stack = []  # Stack stores indices
+
+        for i in range(n):
+            while stack and nums[i] > nums[stack[-1]]:
+                index = stack.pop()
+                result[index] = nums[i]
+            stack.append(i)
+        
+        return result
+
+    def daily_temperatures(self, temperatures):
+        n = len(temperatures)
+        result = [0] * n  # Result array initialized with 0s
+        stack = []  # Monotonic decreasing stack
+
+        for i in range(n):
+            while stack and temperatures[i] > temperatures[stack[-1]]:
+                prev_index = stack.pop()
+                result[prev_index] = i - prev_index
+            stack.append(i)
+
+        return result

patterns/typescript/monotonicStack.ts

@@ -0,0 +1,31 @@
+class MonotonicStack {
+    nextGreaterElement(nums: number[]): number[] {
+        let n = nums.length;
+        let result: number[] = new Array(n).fill(-1); // Default to -1 if no greater element exists
+        let stack: number[] = []; // Stack stores indices
+
+        for (let i = 0; i < n; i++) {
+            while (stack.length > 0 && nums[i] > nums[stack[stack.length - 1]]) {
+                let index = stack.pop()!;
+                result[index] = nums[i];
+            }
+            stack.push(i);
+        }
+        return result;
+    }
+
+    dailyTemperatures(temperatures: number[]): number[] {
+        let n = temperatures.length;
+        let result: number[] = new Array(n).fill(0); // Result array initialized with 0s
+        let stack: number[] = []; // Monotonic decreasing stack
+
+        for (let i = 0; i < n; i++) {
+            while (stack.length > 0 && temperatures[i] > temperatures[stack[stack.length - 1]]) {
+                let prevIndex = stack.pop()!;
+                result[prevIndex] = i - prevIndex;
+            }
+            stack.push(i);
+        }
+        return result;
+    }
+}