LeetCode 20 - Valid Parentheses

https://leetcode.com/problems/valid-parentheses/

Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

An input string is valid if:

1. Open brackets must be closed by the same type of brackets.
2. Open brackets must be closed in the correct order.

Note that an empty string is also considered valid.

Example 1:

Input: "()"
Output: true

Example 2:

Input: "()[]{}"
Output: true

https://leetcode.com/problems/valid-parentheses/discuss/9178/Short-java-solution

        Deque<Character> stack = new LinkedList<>();
        for(int i = 0;i< s.length() ;i++){
            if(s.charAt(i) == ')'){
                if(stack.isEmpty() || (stack.pop() != '(')) return false;
            }else if(s.charAt(i) == ']'){
                if(stack.isEmpty() || (stack.pop() != '[')) return false;
            }else if(s.charAt(i) == '}'){
                if(stack.isEmpty() || (stack.pop() != '{')) return false;
            }else stack.push(s.charAt(i));
        }
        return stack.isEmpty();
    }

public boolean isValid(String s) {
 Stack<Character> stack = new Stack<Character>();
 for (char c : s.toCharArray()) {
  if (c == '(')
   stack.push(')');
  else if (c == '{')
   stack.push('}');
  else if (c == '[')
   stack.push(']');
  else if (stack.isEmpty() || stack.pop() != c)
   return false;
 }
 return stack.isEmpty();
}

https://leetcode.com/articles/valid-parentheses/

  // Hash table that takes care of the mappings.

  private HashMap<Character, Character> mappings;

  // Initialize hash map with mappings. This simply makes the code easier to read.

  public Solution() {

    this.mappings = new HashMap<Character, Character>();

    this.mappings.put(')', '(');

    this.mappings.put('}', '{');

    this.mappings.put(']', '[');

  }

  public boolean isValid(String s) {

    // Initialize a stack to be used in the algorithm.

    Stack<Character> stack = new Stack<Character>();

    for (int i = 0; i < s.length(); i++) {

      char c = s.charAt(i);

      // If the current character is a closing bracket.

      if (this.mappings.containsKey(c)) {

        // Get the top element of the stack. If the stack is empty, set a dummy value of

        // '#'

        char topElement = stack.empty() ? '#' : stack.pop();

        // If the mapping for this bracket doesn't match the stack's top element, return

        // false.

        if (topElement != this.mappings.get(c)) {

          return false;

        }

      } else {

        // If it was an opening bracket, push to the stack.

        stack.push(c);

      }

    }

    // If the stack still contains elements, then it is an invalid expression.

    return stack.isEmpty();

  }