Update stack problems

Author: sudheerj

README.md

@@ -98,15 +98,14 @@ List of Programs related to data structures and algorithms
 
 ### Stack
 
-   1. Sort Stack: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/sortStack.js) 
-   <!--[Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/sortStack.md) -->
+| No. | Name               |                                                                       Source                                                                       | Playground                                                                                                                                                                             |                                                                       Documentation                                                                       | Level  |          Pattern           |
+| :-: | :----------------- | :------------------------------------------------------------------------------------------------------------------------------------------------: | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------: | :----: | :------------------------: |
+|  1  | Sort Stack         |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/1.sortStack/sortStack.js)        | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/1.sortStack/sortStack.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/1.sortStack/sortStack.js)        |  Easy  |      Stack push & pop      |
+|  2  | Balanced Brackets  | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/2.balancedBrackets/balancedBrackets.js) | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/2.balancedBrackets/balancedBrackets.js) | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/2.balancedBrackets/balancedBrackets.md) | Medium |     Stack push and pop     |
+|  3  | Reverse Polish Notation |  [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/3.reversePolishNotation/reversePolishNotation.js)                                                                                                                                                  |  [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/3.reversePolishNotation/reversePolishNotation.js)                                                                                                                                                                                        |  [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/3.reversePolishNotation/reversePolishNotation.md)                                                                                                                                                         | Medium | Stack push & pop |
+|  4  | Daily Temperatures |  [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/4.dailyTemperatures/dailyTemperatures.md)                                                                                                                                                   |  [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/4.dailyTemperatures/dailyTemperatures.js)                                                                                                                                                                                      |  [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/4.dailyTemperatures/dailyTemperatures.md)                                                                                                                                                         | Medium | Monotonic decreasing stack |
+|  5  |  Number of People See In Queue                  | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/5.numberOfPeopleSeeInQueue/numberOfPeopleSeeInQueue.js)                                                                                                                                                    |  [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/5.numberOfPeopleSeeInQueue/numberOfPeopleSeeInQueue.js)                                                                                                                                                                                       | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/5.numberOfPeopleSeeInQueue/numberOfPeopleSeeInQueue.md)                                                                                                                                                          | Medium | Monotonic decreasing stack |
 
-   2. Balanced Brackets: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/balancedBrackets.js) 
-   <!--[Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/balancedBrackets.md)-->
-
-   3. Daily Temperatures: [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/dailyTemperatures/dailyTemperatures.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/dailyTemperatures/dailyTemperatures.md)
-
-   4. Number of People See In Queue: [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/numberOfPeopleSeeInQueue/numberOfPeopleSeeInQueue.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/numberOfPeopleSeeInQueue/numberOfPeopleSeeInQueue.md)
 
 ### LinkedList
 

src/java1/algorithms/stack/BlancedBrackets.java

@@ -0,0 +1,44 @@
+**Description:**
+Given a string `str` which contains the characters '(', ')', '{', '}', '[' and ']'. Determine whether an input string is valid or not by following the below conditions,
+
+1. Open brackets must be closed by the same type of brackets in the correct order.
+2. Each close bracket has a respective open bracket of the same type.
+
+## Examples:
+Example 1
+Input:  str = [()[]{}<>] 
+Output: true
+
+
+Example 2
+Input: str = '[({<>})]'
+Output: true
+
+Example 3
+Input: str = '([)]'
+Output: false
+
+
+**Algorithmic Steps:**
+
+This problem is solved with the help of **stack push and pop** operations to determine the string has valid brackets or not. The algorithmic approach can be summarized as follows:
+
+1. Add preliminary conditions for empty strings, string with one character and odd length. Return `true` if the string is empty and return `false` if the string has one character or length of the string is odd.
+   
+2. Create a stack implementation(i.e, `myStack`) based on array. It includes push, pop and peek operations.
+   
+3. Iterate over the input string `characters` and verify each character with the conditions of switch block.
+   
+4. If the character is an opening bracket(`([{<`), push it to the stack. 
+
+5. If the character is a closing bracket(`>}])`), verify the top element of stack equals to respective opening bracket or not. If so, remove/pop the element to indicate the match. Otherwise, return `false` indicating that the given string is not a balanced.
+
+6. Repeat steps 4-5 until the end of the string.
+
+7. Return `false` if the stack is not empty. That means, there are still few characters which are not balanced.
+
+**Time and Space complexity:**
+
+This algorithm has a time complexity of `O(n)`, where `n` is the number of characters in a string. This is because traversal over the characters in a string at most once. 
+
+Here, we used stack data structure store the opening brackets. In the worst case, the input string may contain only opening brackets. Hence, the space complexity will be O(n).

src/java1/algorithms/stack/balancedBrackets/BalancedBrackets.md

@@ -0,0 +1,63 @@
+package java1.algorithms.stack.balancedBrackets;
+
+import java.util.Stack;
+
+
+class BalancedBrackets {
+
+    static boolean isBalanced(String characters) {
+        if(characters.length() == 0) return true;
+        if(characters.length() == 1 || characters.length()%2 != 0) return false;
+        
+        Stack<Character> myStack = new Stack<>();
+        char[] text = characters.toCharArray();
+        for (char x : text) {
+            switch (x) {
+                case '{':
+                case '<':
+                case '(':
+                case '[':
+                    myStack.push(x);
+                    break;
+                case '}':
+                    if (myStack.peek() == '{') {
+                        myStack.pop();
+                        break;
+                    } else {
+                        return false;
+                    }
+                case '>':
+                    if (myStack.peek() == '<') {
+                        myStack.pop();
+                        break;
+                    } else {
+                        return false;
+                    }
+                case ')':
+                    if (myStack.peek() == '(') {
+                        myStack.pop();
+                        break;
+                    } else {
+                        return false;
+                    }
+                case ']':
+                    if (myStack.peek() == '[') {
+                        myStack.pop();
+                        break;
+                    } else {
+                        return false;
+                    }
+            }
+        }
+        return myStack.empty();
+    }
+
+    public static void main(String args[]) {
+        String str1 = "()[]{}<>";
+        String str2 = "[({<>})]";
+        String str3 = "([)]>";
+        System.out.println(isBalanced(str1));
+        System.out.println(isBalanced(str2));
+        System.out.println(isBalanced(str3));
+    }
+}

src/java1/algorithms/stack/balancedBrackets/BlancedBrackets.java

@@ -1,5 +1,5 @@
 //Hashmap:- TC:O(n) SC:O(n)
-package java1.algorithms.stack;
+package java1.algorithms.stack.balancedParentheses;
 
 import java.util.*;
 

src/java1/algorithms/stack/BalancedParentheses.java src/java1/algorithms/stack/balancedParentheses/BalancedParentheses.java

@@ -1,3 +1,17 @@
+**Description:**
+Given an array of integers `temperatures`, which represents the daily temperatures in a city. For each temperature, calculate how many days one would have to wait for a warmer temperature than the current day. i.e, Find an array `answer` such that `answer[i]` represents the number of days you have to wait after the `i`th day to get a warmer temperature.
+
+**Note:** If there is no future day with a warmer temparature, just return 0.
+
+## Examples:
+Example 1
+Input:  temperatures1 = [72,73,74,70,68,71,75,72]
+Output: [1, 1, 4, 2, 1, 1, 0, 0]
+
+Example 2
+Input: temperatures2 = [10, 20, 30,40,50,60,70]
+Output: [1, 1, 1, 1, 1, 1, 0]
+
 **Algorithmic Steps**
 This problem is solved with the help of monotonic decreasing stack. The algorithmic approach can be summarized as follows:
 
@@ -16,6 +30,6 @@ This problem is solved with the help of monotonic decreasing stack. The algorith
 7. Return the days array which indicate elements of number of days to get a warmer temperature
 
 **Time and Space complexity:**
-This algorithm has a time complexity of O(n)(i.e, O(n + n)), where n is the number of days in the temperatures list. This is because each element is processed by pushing an element into a stack and then processed again when the element is popped-out. Here, each element is pushed and popped at most once with a linear time. 
+This algorithm has a time complexity of `O(n)(i.e, O(n + n))`, where n is the number of days in the temperatures list. This is because each element is processed by pushing an element into a stack and then processed again when the element is popped-out. Here, each element is pushed and popped at most once with a linear time. 
 
-Also, it takes space complexity of O(n) with the use of stack data structure. In the worst case(all temperatures in decreasing order), the stack will contain all temperature indices.
+Also, it takes space complexity of `O(n)` with the use of stack data structure. In the worst case(all temperatures in decreasing order), the stack will contain all temperature indices.

src/java1/algorithms/stack/balancedParentheses/BalancedParentheses.md

@@ -10,9 +10,8 @@ private static int[] canSeePersonsCount(int[] heights) {
         int[] visibilityCount = new int[length];
         Stack<Integer> stack = new Stack<>();
 
-
         for(int i=length-1; i>-1; i--) {
-            while(!stack.isEmpty() && stack.peek() < heights[i]) {
+            while(!stack.isEmpty() && heights[i] > stack.peek()) {
                 stack.pop();
                 ++visibilityCount[i];
             }

src/java1/algorithms/stack/dailyTemperatures/DailyTemperatures.md

@@ -1,3 +1,19 @@
+**Description:**
+Given an array `heights` of distinct integers where `heights[i]` represents the height of the `i`th person. These heights represents `n` people standing in a queue numbered from `0` to `n - 1` in left to right order.  Return an array `answer`, where `answer[i]` is the number of people that person `i` can see to their right in the queue.
+
+## Examples:
+Example 1
+Input:  heights1 = [10,6,8,5,11,9]
+Output: [3, 1, 2, 1, 1, 0]
+
+Example 2
+Input: heights2 = [6, 5, 4, 3, 2, 1]
+Output: [1, 1, 1, 1, 1, 0 ]
+
+Example 3
+Input: heights2 = [1, 2, 3, 4, 5, 6]
+Output: [1, 1, 1, 1, 1, 0 ]
+
 **Algorithmic Steps**
 This problem is solved with the help of monotonic decreasing stack. The algorithmic approach can be summarized as follows:
 
@@ -9,16 +25,16 @@ This problem is solved with the help of monotonic decreasing stack. The algorith
 
 4. Iterate over the input array using an iteration variable `i` from backwards(i.e, from end of array to 0). This reverse iteration aligns with the direction of visibility (i.e,rightwards)
 
-5. Inside the loop(step4), create a while loop to pop elements from stack if the top element is less than current person's height. Also, as part of this nested loop, increment the visibility count by 1 because popped person is directly visible 
+5. Inside the loop(step4), create a while loop to pop elements from stack if current person's height is greater than the top element. Also, as part of this nested loop, increment the visibility count by 1 because popped person is directly visible 
 to the current person.
 
-5. Upon removing all the shorter people from the previous step, if the stack is still not empty, it indicates that there is atleast one taller person compared to the current person. In this case, the visibility count is incremented by 1.
+6. Upon removing all the shorter people from the previous step, if the stack is still not empty, it indicates that there is atleast one taller person compared to the current person. In this case, the visibility count is incremented by 1.
 
-6. Add the current taller person height to the stack.
+7. Add the current taller person height to the stack.
 
-7. Return the visibility count array which indicate number of persions of visible at each position.
+8. Return the visibility count array which indicate number of persions of visible at each position.
 
 **Time and Space complexity:**
-This algorithm has a time complexity of O(n), where n is the number of people a person can see. This is because we are iterating the array only once. However, each element performs multiple comparisons along with pop operations from the stack until a higher height is found. In the worst, each element will be pushed and popped from the stack once, leads to time complexity of O(n). So the overall time complexity is O(n).
+This algorithm has a time complexity of `O(n)`, where `n` is the number of people a person can see. This is because we are iterating the array only once. However, each element performs multiple comparisons along with pop operations from the stack until a higher height is found. In the worst, each element will be pushed and popped from the stack once, leads to time complexity of `O(n)`. So the overall time complexity is `O(n)`.
 
-Also, it takes space complexity of O(n) with the help of stack and array data structures, using `n` number of elements. In the worst case(when heights are in ascending order), the stack will contain all people heights.
+Also, it takes space complexity of `O(n)` with the help of stack and array data structures, using `n` number of elements. In the worst case(when heights are in ascending order), the stack will contain all people heights.