Boolan C++ STL与泛型编程 第三周笔记

本周的作业题目如下：

         如果给你一个字符串，它只包含下面的几个字符:’(‘、’)’、’{‘、’} ’、’[’、‘]’，你需要判断输入的字符串是否是一个有效的圆括号字符串。例如“（（（[[]]）））”是有效的，但是“{{}”和“((”则不是。

提示：根据经验，必须选用一种最合适的STL容器来完成该题，必须写上测试代码。

 

题目给出的解题分析如下：

比较明显的是，为了判断有效，我们必须从头扫描整个字符串，问题在于我们不能立即判断，因为当前节点依赖后续节点，因此我们需要将栈作为辅助工具。

具体操作为：如果是左括号入栈，直到读到所依赖的右括号，再从栈中弹出该节点，如果当前节点是右括号，则栈顶必须是相依赖的左括号，否则输入无效。当扫描完全部，栈应该为空，否则无效。

 

因为作为初学者，在看到解题分析的时候完全是一脸懵，因为之前的所有课程都没有提到过所谓的“入栈”、“节点”、“栈顶”等，对这名字完全没有任何了解。

所以呢，就先把题目给出的分析扔到了一边，以一个萌新的角度思考了下这个问题该怎么解决。

        

         对于括号来说，肯定是两两左右配对的，那么是否我可以简单的统计一串字符串中左括号的数量和右括号的数量来进行对比分析呢？比如（（（[[]]））），有三个“（”，三个“）”，两个“[”，两个“]”。那么就认为其是有效的。

         好像可以噯，但是…

         对于一些字符串像这样：

         其左右括号的数量是对应的，但是理论上来说这样的字符串是无效的。

 

         嗯，那要怎么搞呢下来…

         好吧，查资料，看看题目给的分析到底几个意思吧

        

         题目给的分析是这么操作的：

如果左括号入栈，直到读到所依赖的右括号，再从栈中弹出该节点。

弹出该节点是什么意思？是把左右两个括号都从栈中拿掉，还是说把左右两个括号及其中间的东西都拿掉？

还是用上面那幅图来分析，若只是把左右两个括号拿掉，那么上图结果将是有效，明显错误。

那么结果应该是将左右两个括号和他们中间的东西都从栈中拿掉。

这样循环完毕，如果栈为空，则括号有效，否则无效

 

         接下来就是见证奇迹的时候了：

                   我分别用代码实现统计方法和栈的方法来对上面的分析进行验证。

统计方法代码如下：

#include<iostream>

#include<string>

 

using namespace std;

 

int main()

{

         stringss;

         intl_n_x=0,r_n_x=0;

         intl_n_z=0,r_n_z=0;

         intl_n_d=0,r_n_d=0;

         cout<< "请输入需要分析验证的字符串： "<<endl;

         cin>> ss;

         for(auto i:ss)

         {

                   switch(i)

                   {

                   case'(':

                            ++l_n_x;

                            break;

                   case'[':

                            ++l_n_z;

                            break;

                   case'{':

                            ++l_n_d;

                            break;

                   case')':

                            ++r_n_x;

                            break;

                   case']':

                            ++r_n_z;

                            break;

                   case'}':

                            ++r_n_d;

                            break;

                   }

         }

         cout<<"左小括号数："<< l_n_x << "|"<<"右小括号数："<< r_n_x << endl;

         cout<< "左中括号数：" << l_n_z << "|" << "右中括号数："<< r_n_z << endl;

         cout<< "左大括号数：" << l_n_d << "|" << "右大括号数："<< r_n_d << endl;

         if(l_n_d==r_n_d && l_n_x==r_n_x && l_n_z==l_n_z)

         {

                   cout<< "字符串有效" << endl;

         }

         else

         {

                   cout<< "字符串无效" << endl;

         }

        

}

 

测试结果如下：

1.      测试((([[]]))):

2.      测试{{}

 

3.

3. 测试（（

可以看出，到目前为止，测试作为给的字符串都是正确的。

3.      测试

结果果然是与实际不符合的，证明了之前的分析，这种方法存在这缺陷。

 

接下来验证方法二，

 

对于方法二，该选用哪种合适的容器呢？

按照之前的分析，我们需要将成对的两个括号之间的内容拿掉，

在循环的过程中判断右括号很简单，问题是怎么找到之前的左括号的位置呢？

这应该就需要查找

查找的话，对于顺序容器来说效率就比较低

对于关联容器，因为我们需要将两个括号之间的东西也一起拿掉，那么我们就需要元素有序的存放

当然我们也需要元素的重复

因此，目标初步锁定为multiset

 

然而、但是

 

在multiset中，重复元素是相邻存放的。意思就是若是有相同元素，他就不是我们想要的有序存放。

验证代码及结果如下：

#include<iostream>

#include<string>

#include<set>

 

usingnamespace std;

 

intmain()

{

multiset<char> ch;

string ss;

cout << "请输入需要分析验证的字符串： " << endl;

cin >> ss;

for (auto i : ss)

{

           ch.insert(i);

}

for (auto i : ch)

{

           cout << i << endl;

    }

 

好吧，看来还是要选择顺序容器拉

接着分析，我们要在重复的元素中进行查找，而且查找的是最近一个相匹配的元素，

而find查找的是第一次出现的元素

那么解决方法应该是容器元素的插入是从头部开始插而不是尾部

这样find所查找的东东就一定是我们想要的那个

Ok，到这，我们需要的是一个能从头部插入的顺序容器

Vector 只能在尾部插，排除

Array 不能插，排除

List、forward_list、deque 都支持push_front

选哪一个好呢？

Deque删除除首尾外的任何元素都会使所有迭代器、引用、指针失效。

但是我们需要一次性删除两个括号之间的所有东东呀，感觉跟deque不是很合适呢

呐 还剩下list和forward_list楞个办呐

List 双向，任何位置都可以插、可以拔

Forward_list 单向，任何位置都可以插、可以拔

嗯，看看书，发现forward_list好像很矫情，删除元素的话需要有特殊的操作。

算了 还是list来试试吧

 

代码如下：

#include<iostream>

#include<string>

#include<list>

#include<algorithm>

 

usingnamespace std;

 

intmain()

{

list<char> ch;

string ss;

cout << "请输入需要分析验证的字符串： " << endl;

while (cin>>ss)

{

           for (auto i : ss)

           {

                    auto find_iterator_x =find(ch.cbegin(), ch.cend(), '(');

                    auto find_iterator_z =find(ch.cbegin(), ch.cend(), '[');

                    auto find_iterator_d =find(ch.cbegin(), ch.cend(), '{');

                   

                    switch (i)

                    {

                    case')':

                             if (find_iterator_x!= ch.cend())

                             {

                                       ch.erase(ch.begin(),++find_iterator_x);

                             }

                             break;

                    case']':

                             if (find_iterator_z!= ch.cend())

                             {

                                       ch.erase(ch.begin(),++find_iterator_z);

                             }

                             break;

                    case'}':

                             if (find_iterator_d!= ch.cend())

                             {

                                       ch.erase(ch.begin(),++find_iterator_d);

                             }

                             break;

                    default:

                            ch.push_front(i);

                    }

           }

           cout << "取出匹配括号后，栈中剩余元素为：" << endl;

           for (auto i : ch)

                    cout << i <<endl;

           cout <<"-----------------------------------------------" << endl;

           if (ch.cbegin() == ch.cend())

           {

                    cout << "所输入字符串有效！"<< endl;

           }

           else

           {

                    cout << "所输入字符串无效！"<< endl;

           }

           ch.clear();

}

}

好吧，尴尬的事情还是发生了

在最后一个验证中，对于图中这种情况依然无效。

那楞个办嘞？

 

重新分析！！！！

 

针对上图中的例子进行分析，

首先，若是左括号，那么入栈，无疑问

其次，若是遇到右括号，直接与栈顶进行比较，若不匹配，就认为无效

再次，若该又括号与栈顶匹配，那么弹出栈顶，又括号也不进栈，进行下一个

 

貌似这么分析的话，应该是行的通的哈

So…

修改代码如下：

#include<iostream>

#include<string>

#include<list>

#include<algorithm>

 

usingnamespace std;

 

intmain()

{

list<char> ch;

string ss;

cout << "请输入需要分析验证的字符串： " << endl;

while (cin>>ss)

{

           for (auto i : ss)

           {

                   

                    switch (i)

                    {

                    case')':

                             if (ch.empty()||*ch.cbegin()!='(')

                             {

                                       cout<< "所输入字符串无效！" << endl;

                                       exit(0);

                             }

                             else

                             {

                                       ch.erase(ch.begin());

                             }

                             break;

                    case']':

                             if (ch.empty() ||*ch.cbegin() != '[')

                             {

                                       cout<< "所输入字符串无效！" << endl;

                                       exit(0);

                             }

                             else

                             {

                                       ch.erase(ch.begin());

                             }

                             break;

                    case'}':

                             if (ch.empty() ||*ch.cbegin() != '{')

                             {

                                       cout<< "所输入字符串无效！" << endl;

                                       exit(0);

                             }

                             else

                             {

                                       ch.erase(ch.begin());

                             }

                             break;

                    default:

                              ch.push_front(i);

                    }

           }

           if (ch.empty())

           {

                    cout << "所输入字符串有效！"<< endl;

           }

           else

           {

                    cout << "所输入字符串无效！"<< endl;

           }

           ch.clear();

           cout << "大侠，再来一个试试吧！请："<< endl;

}

}

 

嗯嗯

搞了一天，终于搞定了！！！