[C++]LeetCode: 22 Valid Parentheses

题目：

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

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

错误思路1：首先获取s中的第一个字符（六种可能，除去空字符），然后匹配出对应字符。之后判断是否最后一个字符为匹配字符，且两者间中有其字符。

误区！！！忘记考虑“(){}[]”的情况。

Error Code:

class Solution {
public:
    bool isValid(string s) {
        //判断一个字符串是否为空，字符串只包含三种括号。
        //思路：首先获取s中的第一个字符（六种可能，除去空字符），然后匹配出对应字符。之后判断是否最后一个字符为匹配字符，且两者间中有其字符。
        //Attention:
        
        if(s.length() == 0)
            return true;
        
        bool ret;
        
        int strlength = s.length();
        
        char fstchar = s[0];
        
        char matchchar;
        
        swith(fstchar)
        {
            case '(':
            {
                matchchar = ')';
                break;
            }
            case ')':
            {
                matchchar = '';
                break;
            } 
            case '{':
            {
                matchchar = '}';
                break;
            }
            case '}':
            {
                matchchar = '';
                break;
            }
            case '(':
            {
                matchchar = ')';
                break;
            }
            case '[':
            {
                matchchar = '';
                break;
            }
            default:
                return false;
        }
        
        return s[strlength -1] == matchchar;
    }
};

错误思路2：建立一个map,储存对应的匹配字符。括号必须成对出现，并且中间不能有其他字符。符合这两点的才是valid
误区！！！"（【】）"也算valid 中间可以有成对出现的括号字符。

Submission Result: Wrong Answer

Input:	"([])"
Output:	false
Expected:	true

ERROR Code:

class Solution {
public:
    bool isValid(string s) {
        //思路：建立一个map,储存对应的匹配字符。括号必须成对出现，并且中间不能有其他字符。符合这两点的才是valid
        
        if(s.length() == 0)
            return true;
        if(s.length() == 1)
            return false;
            
        map<char, char> BracketsHash;
        typedef map<char, char>::value_type valType;
        
        int strLength = s.length();
        char lchar;
        bool ret = true;
        
        //初始化map
        BracketsHash.insert(valType('(', ')'));
        BracketsHash.insert(valType('{', '}'));
        BracketsHash.insert(valType('[', ']'));
        
        for(int i = 1; i < strLength;)
        {
            lchar = s[i - 1];
            //如果lchar不是左括号，直接返回false.
            if(BracketsHash.find(lchar) == BracketsHash.end())
                return false;
                
            if(BracketsHash.find(lchar) != BracketsHash.end() && BracketsHash[lchar] == s[i])
            {   
                i += 2;  
            }
            else
            {
                return false;
            }
        }
        
        return ret;
    }
};

正确思路：选择合适的数据结构 stack，总是保存左边最邻近的字符。

Attention: 每次对比时都需要先获取顶部字符，然后必须pop; 最后一步判断很重要，必须保证括号是成对出现的。"[[]()"就是false.

复杂度：O(n)

AC Code:

class Solution {
public:
    bool isValid(string s) {
        //选择合适的数据结构 stack，总是保存左边最邻近的字符。
        
        if(s.length() == 0)
            return true;
        
        stack<char> brckstack;
        
        for(int i = 0; i < s.length(); i++)
        {
            if(s[i] == '(' || s[i] == '{' || s[i] == '[')
                brckstack.push(s[i]);
            else
            {
                if(brckstack.size() == 0) return false;
                //此处比较巧妙，先获取顶部的字符，然后再pop,以此来获取stack最顶的字符。
                char lchar = brckstack.top();
                brckstack.pop();
                if(s[i] == ')' && lchar != '(') return false;
                if(s[i] == '}' && lchar != '{') return false;
                if(s[i] == ']' && lchar != '[') return false;
            }
        }
        // ~是按位取反，！是取逻辑非。if(~brckstack.empty()) 是错误的。
        //这步判断很重要，必须保证括号是成对出现的。"[[]()"就是false.
        if(!brckstack.empty())
            return false;
        else
            return true;
    }
};