Added BalancedParenthesesChecker.cs, NextGreaterElement.cs and ReverseStack.cs

DataStructures/Stack/BalancedParenthesesChecker.cs

@@ -0,0 +1,56 @@
+using System;
+namespace DataStructures.Stack
+{
+    /// <summary>
+    ///     It checks if an expression has matching and balanced parentheses.
+    /// @author Mohit Singh
+    /// @author <a href="https://github.com/mohit-gogitter">mohit-gogitter</a>
+    /// </summary>
+    public class BalancedParenthesesChecker
+    {
+        private static readonly Dictionary<char, char> ParenthesesMap = new Dictionary<char, char>()
+        {
+            { '(', ')' },
+            { '{', '}' },
+            { '[', ']' },
+        };
+        /// <summary>
+        ///     This method checks if an expression has matching and balanced parentheses.
+        /// </summary>
+        /// <param name="expression">string containing parenthesis</param>
+        /// <returns>Boolean value</returns>
+        public static bool IsBalanced(string expression)
+        {
+            Stack<char> stack = new Stack<char>();
+            foreach (char c in expression)
+            {
+                if (c == '(' || c == '{' || c == '[')
+                {
+                    stack.Push(c);
+                }
+                else if (c == ')' || c == '}' || c == ']')
+                {
+                    if (stack.Count == 0)
+                    {
+                        return false;
+                    }
+                    char open = stack.Pop();
+
+                    if (!IsMatchingPair(open, c))
+                    {
+                        return false;
+                    }
+                }
+                else
+                {
+                    //since there are no other brackets, this is unreachable code
+                }
+            }
+            return stack.Count == 0;
+        }
+        private static bool IsMatchingPair(char open, char close)
+        {
+            return ParenthesesMap.ContainsKey(open) && ParenthesesMap[open] == close;
+        }
+    }
+}

DataStructures/Stack/NextGreaterElement.cs

@@ -0,0 +1,33 @@
+using System;
+namespace DataStructures.Stack
+{
+    /// <summary>
+    ///     For each element in an array, the utility finds the next greater element on the right side using a stack.
+    /// @author Mohit Singh
+    /// @author <a href="https://github.com/mohit-gogitter">mohit-gogitter</a>
+    /// </summary>
+    public class NextGreaterElement
+    {
+        /// <summary>
+        ///     For each element in an array, this method finds the next greater element on the right side using a stack.
+        /// </summary>
+        /// <param name="nums">Integer Array for which NextGreaterElement needs to be computed</param>
+        /// <returns>Integer array containing next greater elements</returns>
+        public static int[] FindNextGreaterElement(int[] nums)
+        {
+            Stack<int> stack = new Stack<int>();
+            int[] result = new int[nums.Length];
+
+            for (int i = nums.Length - 1; i >= 0; i--)
+            {
+                while (stack.Count > 0 && stack.Peek() <= nums[i])
+                {
+                    stack.Pop();
+                }
+                result[i] = stack.Count == 0 ? -1 : stack.Peek();
+                stack.Push(nums[i]);
+            }
+            return result;
+        }
+    }
+}

DataStructures/Stack/ReverseStack.cs

@@ -0,0 +1,40 @@
+using System;
+namespace DataStructures.Stack
+{
+    /// <summary>
+    ///     Reverses the elements in a stack using recursion.
+    /// @author Mohit Singh
+    /// @author <a href="https://github.com/mohit-gogitter">mohit-gogitter</a>
+    /// </summary>
+    public class ReverseStack
+    {
+        /// <summary>
+        ///    This method reverses the elements in a stack using recursion.
+        /// </summary>
+        /// <param name="stack">A Stack of Generic Type</param>
+        public static void Reverse<T>(Stack<T> stack)
+        {
+            if (stack.Count == 0)
+            {
+                return;
+            }
+            T temp = stack.Pop();
+            Reverse(stack);
+            InsertAtBottom(stack, temp);
+        }
+
+        private static void InsertAtBottom<T>(Stack<T> stack, T value)
+        {
+            if (stack.Count == 0)
+            {
+                stack.Push(value);
+            }
+            else
+            {
+                T temp = stack.Pop();
+                InsertAtBottom(stack, value);
+                stack.Push(temp);
+            }
+        }
+    }
+}

README.md

@@ -242,6 +242,9 @@ find more than one implementation for the same objective but using different alg
     * [Array-based Stack](./DataStructures/Stack/ArrayBasedStack.cs)
     * [List-based Stack](./DataStructures/Stack/ListBasedStack.cs)
     * [Queue-based Stack](./DataStructures/Stack/QueueBasedStack.cs)
+    * [Next Greater Element](./DataStructures/Stack/NextGreaterElement.cs)
+    * [BalancedParenthesesChecker](./DataStructures/Stack/BalancedParenthesesChecker.cs)
+    * [Reverse Stack](./DataStructures/Stack/ReverseStack.cs)
   * [Heap](./DataStructures/Heap)
     * [Min-Max Heap](./DataStructures/Heap/MinMaxHeap.cs)
     * [Binary Heap](./DataStructures/Heap/BinaryHeap.cs)