[LintCode] Valid Parentheses

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

Example

The brackets must close in the correct order, "()" and "()[]{}" are all valid but "(]" and "([)]" are not.

This problem itself is pretty straightforward in developing a solution. Each time we try to check a parenthese pair, 

we need to get the previous character that was just scanned, indicating a LIFO visit order. So we need to use the

stack data structure as follows.

1.  Each time we have a right side parenthese, we check the stack. If the stack is either empty or its top element is

not a matching left side parenthese, return false.

2. If we have a left side parenthese, simply push it to the stack.

3. After all characters have been iterated, check if the stack is empty. If empty, return true, otherwise return false. 

public class Solution {
    /**
     * @param s A string
     * @return whether the string is a valid parentheses
     */
    public boolean isValidParentheses(String s) {
        if(s == null){
            return false;
        }
        if(s.length() == 0){
            return true;
        } 
        if(s.length() % 2 != 0){
            return false;
        }
        Stack<Character> stack = new Stack<Character>();
        int idx = 0;
        while(idx < s.length()){
            switch(s.charAt(idx)){
                case ')':
                    if(stack.isEmpty() || stack.pop() != '('){
                        return false;
                    }
                    break;
                case '}':
                    if(stack.isEmpty() || stack.pop() != '{'){
                        return false;
                    }
                    break;
                case ']':
                    if(stack.isEmpty() || stack.pop() != '['){
                        return false;
                    } 
                    break;
                default:
                    stack.push(s.charAt(idx));
                    break;
            }
            idx++;
        }
        return stack.isEmpty();
    }
}

Runtime: O(n), BCR

Space complexity: O(n)

Both runtime and space complexity are optimal. 

The following implementation is more concise with fewer duplicated code and easier to change if the input parentheses set has more options. 

public class Solution {
    public boolean isValidParentheses(String s) {
        if(s == null){
            return false;
        }
        if(s.length() == 0){
            return true;
        } 
        if(s.length() % 2 != 0){
            return false;
        }
        Stack<Character> stack = new Stack<Character>();
        int idx = 0;
        while(idx < s.length()){
            char c = s.charAt(idx);
            if(")}]".contains(String.valueOf(c))){
                if(!stack.isEmpty() && isMatch(stack.peek(), c)){
                    stack.pop();
                }
                else{
                    return false;
                }
            }
            else{
                stack.push(c);
            }
            idx++;
        }
        return stack.isEmpty();
    }
    private boolean isMatch(char c1, char c2){
        return (c1 == '(' && c2 == ')') || (c1 == '{' && c2 == '}')
            || (c1 == '[' && c2 == ']');        
    }
}