我的解法：时间复杂度O（N）

一旦出现左型括号，先存储起来就准备与右型括号配对，假设是右型括号，就运行配对（检查存储之中是否有左型括号）！

从标签来看，利用栈来完毕如此操作，左型括号先压栈等待匹配，

右型括号就查看栈顶是否是左型括号（假设不是已经不匹配了。"([)]" are not.）

最后通过栈是否是空的来推断是否是全然配对

class Solution {

public:

    bool isValid(string str) {

        stack<char> s;

        if(str.size() <= 1)

             return false;

        for(int i=0;i<str.size();i++)

        {

            switch(str[i])

            {

                //左型括号直接压栈

                case '(' :

                 s.push('(');

                 break;

                case '{' :

                 s.push('{');

                 break;

                case '[' :

                 s.push('[');

                 break;

                 //右型括号运行匹配操作，能匹配则弹出栈顶，不能则返回false

                case ')' :

                 if(s.empty())

                 {

                     return false;

                 }else{

                     char ch=s.top();

                     if(ch=='(')

                      {

                          s.pop();

                          continue;

                      }else{

                          return false;

                          break;

                      }

                 }

                 break;

                 case '}' :

                 if(s.empty())

                 {

                     return false;

                 }else{

                     char ch=s.top();

                     if(ch=='{')

                      {

                          s.pop();

                          continue;

                      }else{

                          return false;

                          break;

                      }

                 }

                 break;

                 case ']' :

                 if(s.empty())

                 {

                     return false;

                 }else{

                     char ch=s.top();

                     if(ch=='[')

                      {

                          s.pop();

                          continue;

                      }else{

                          return false;

                          break;

                      }

                 }

                 break;

            }

        }

        //最后若是空则完毕匹配

        if(s.empty())

            return true;

        else

             return false;

    }

};

学习别人的算法：

运用数据结构红黑树map来存储配对的括号，以便查找匹配情况（时间浮渣度N*lg（N））

一旦出现左型括号，就存储相应的右型括号，

假设是右型括号，就运行配对（检查存储之中是否有左型括号）！

假设匹配则删除vector的最后一个元素

最后通过vc是否是空的来推断是否是全然配对

class Solution {

public:

    bool isValid(string s)

    {

        vector<char> vc;

        map<char, char> mapping;

        mapping['('] = ')';

        mapping['{'] = '}';

        mapping['['] = ']';

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

        {

            if (s[i] == '(' || s[i] == '{' || s[i] == '[') //假设是左型括号。就直接压入相应的右型括号到vector

                vc.push_back(mapping[s[i]]);

            else if (vc.empty() || vc.back() != s[i])//假设右型括号的不匹配情况

                return false;

            else         //右型括号的匹配情况

                vc.pop_back();//删除vector中的最后一个元素

        }

        return vc.empty() ?

true : false;

    }

};

注：本博文为EbowTang原创，兴许可能继续更新本文。假设转载，请务必复制本条信息！

原文地址：http://blog.csdn.net/ebowtang/article/details/50380804

原作者博客：http://blog.csdn.net/ebowtang