题目：括号匹配分析
给定字符串，输出括号是否匹配，例如，
-
"()" yes；
-
")(" no；
-
"(abcd(e)" no；
-
"(a)(b)" yes。
要求必须用递归写，整个实现不可以出现一个循环语句。
分析
这个题目很多同学都见过了，如果没有后面的条件，会张口就说就来用栈来实现，时间复杂度O(n)，空间复杂度O(n)。这个是很好的一个解答，没有 问题的。但是我们在做面试题，准备面试的过程中，每一个题目都不应该仅仅局限于某一个方法。应该尝试更多的思路，尽管有些思路的时间、空间复杂度并不是很 好，但是可以带来变化，举一反三，这才是真正的收获。
这个题要求了，只目能使用递归并且不能出现循环语句。这个时候，我们应该如何处理呢？其实告诉了大家递归，就比较好想了：怎么定义好问题和子问题。
如果字符串中的括号是匹配的，则'('的数量和')'的数量是相等的，反之是不相等的。这样，在递归的过程中，可以保存一个变量，用来记录'('的 数量和')'的数量是否匹配。这样定义递归问题f(p,count)，表示当前字符p之前的字符串中'('的数量和')'的数量的匹配情况，p表示指向当 前字符的指针。初始的时候，f(p, 0)，递归的过程如下：
-
如果p为空，则考察count是否为0，如果为0，则匹配；如果不为0，则不匹配；
-
如果不为空，则考察当前字符p，如果p='('，则递归调用f(p++, count++);如果p=')'，则递归调用f(p++, count--)。如果p是其他的字符，并不是'('和')'，则递归调用f(p++, count)，count不变，继续考虑下一次字符。其中需要检查和保证count>=0.
其实，递归的问题有的时候不是那么好像的，需要大家不断的练习。如果不采用count来记录括号匹配的情况，这个题目的递归也不好想。
基于栈的代码：
bool isMatched(const char *str) { stack<char> s; while(*str) { if(*str=='(') { s.push('('); } else if(*str==')') { if(!s.empty())//这里很重要，保证了如果输入)(，就直接退出 { s.pop(); } else { return false; } } str++; } return s.empty(); }
递归的代码：下面是我刚开始写的，有什么错误吗？
bool isMatchedRec(char *p,int count) { if(*p==' ') { return count==0;//如果p为空，则考察count是否为0，如果为0，则匹配；如果不为0，则不匹配； } else { if(*p=='(') { //return isMatchedRec(p++,count++); 错误，在递归内要写前缀++，不要写后缀，否则无穷递归。 return isMatchedRec(++p,++count); } else if(*p==')') { return isMatchedRec(++p,--count); } else { return isMatchedRec(++p,count); } } }
错误在哪里；
假设我们输入“）（”,返回的还是true。
原因是没有没有检查count>=0.
正确的代码：
bool isMatchedRec(char *p,int count) { if(*p==' ') { return count==0;//如果p为空，则考察count是否为0，如果为0，则匹配；如果不为0，则不匹配； } else { if(count>=0) { if(*p=='(') { return isMatchedRec(++p,++count); } else if(*p==')') { return isMatchedRec(++p,--count); } else { return isMatchedRec(++p,count); } } else return false; } }
可以把上面代码再简化下：
bool isMatchedRec2(const char* s,int count) { if(count<0) return false; if(*s==' ') { return count==0; } else { if(*s=='(') count++; else if(*s==')') count--; } return isMatchedRec2(++s,count); }
参考：http://blog.csdn.net/buaa_shang/article/details/11726619
扩展问题；
假设字符串中包含{,[,( 三种括号，请判断是否匹配。
http://blog.chinaunix.net/uid-28458801-id-3664897.html
bool isPair(char a,char b) { bool flag=true; if(a=='{' && b=='}') flag=true; else if(a=='[' && b==']') flag=true; else if(a=='(' && b==')') flag=true; else flag=false; return flag; } bool isMatched(const char *str) { stack<char> s; while(*str) { if(*str=='{' || *str=='[' || *str=='(' ) { /*if( (s.top()=='{') || (s.top()=='['&&*str!='{') && (s.top()=='('&& *str=='(') ) s.push(*str); else return false; */ s.push(*str); } else if(*str=='}' || *str==']' || *str==')' ) { if(!s.empty())//这里很重要，保证了如果输入)(，就直接退出 { if(isPair(s.top(),*str)) { s.pop(); } else { return false; } } else { return false; } } str++; } return s.empty(); }
题目扩展
给你一个字符串，里面只包含"(",")","[","]","{","}"几种符号，请问你需要至少添加多少个括号才能使这些括号匹配起来。
例如：
[]是匹配的，所需括号个数为 0；([])[]是匹配的， 所需括号个数为 0；((]是不匹配的， 所需最少括号个数为 3；([)]是不匹配的，所需最少括号个数为 2.
这道变种题大多数人的解题思路都是动态规划，思路如下。不知道大家有没有好的别的方法，求教。
1）用 dp[i][j] 表示从位置 i 到字符位置 j 所需的最少括号数。假定字符串是 “[ ( )”, 那么 dp[0][0] = dp[1][1] = dp[2][2] = 1。
2）如果我们要算dp[i][j+1], 那么，最坏的情况是使得没有被匹配的括号数增加了，即 dp[i][j+1] 最多为 min( dp[i][j] + 1, dp[i+1][j+1] + 1). 但是，这可能不是我们想要的答案，因为在刚才的例子里，即：假定字符串是 “[ ( )”, 那么 dp[0][1] = dp[0][0] + 1= 2， 但是 dp[1][2] 却不等于 dp[1][1] + 1.
3）那么，什么情况下dp[i][j+1] = dp[i][j] + 1？只有当 字符串里从i 到 j 没有任何字符与第 j + 1 个字符匹配的时候。但是，如果存在和第 j + 1 个字符匹配的情况，问题就不一样了。
4）假设在i 到 j 之间存在一个字符（比如在位置 k）与第 j + 1 个字符匹配，那么我们相当于把原来的字符串分成了两个部分dp[i][k-1] 和 dp[k+1][j], 因为第k 个 和 j + 1 个字符已经匹配掉了。而且，我们不会再考虑 i 到 k - 1 的字符会和 k + 1 到 j 之间的字符匹配的情况，因为我们已经把这两个部分完全分开了。话句话说 dp[i][j+1] = min(min( dp[i][j] + 1, dp[i+1][j+1] + 1), dp[i][k-1] + dp[k+1][j]).
#include<iostream> #include<string> #include<memory.h> using namespace std; bool is(char a, char b){ if(a == '(' && b == ')') return 1; if(a == '[' && b == ']') return 1; if(a == '{' && b == '}') return 1; return 0; } int main(){ //dp[i][j] 表示从第i位至第j位的最小匹配长度 int t, i, j, k, dp[105][105]; cin >> t; while(t--){ string s; cin >> s; memset(dp, 0, sizeof(dp)); for(i = 0; i <= s.length(); ++i){ dp[i][i] = 1; } for(i = 2; i <= s.length(); ++i){ for(j = i - 1; j >= 1; --j){ dp[j][i] = dp[j][i - 1] + 1; for(k = j; k < i; ++k){ if(is(s[k - 1], s[i - 1])){ dp[j][i] = min(dp[j][i], dp[j][k - 1] + dp[k + 1][i - 1]); } } } } cout << dp[1][s.length()] << endl; } return 0; }
改写的更容易看懂 的代码：
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j])k [i，j)
bool isPair(char a,char b) { if(a == '(' && b == ')') return 1; if(a == '[' && b == ']') return 1; if(a == '{' && b == '}') return 1; return 0; } int match(int dp[100][100],char s[]) { for(int i=0;i<100;i++) for(int j=0;j<100;j++) dp[i][j]=0; int len=strlen(s); for(int i=0;i<=len;i++) dp[i][i]=1; for(int j=2;j<=len;j++) { for(int i=j-1;i>=1;i--) //i从1开始,说明dp[0]不存 { dp[i][j]=dp[i][j-1]+1; for(int k=i;k<j;k++) { if(isPair(s[k-1],s[j-1])) { dp[i][j]=min(dp[i][j],dp[i][k-1]+dp[k+1][j-1]); } } } } return dp[1][len]; }
递归版：
//递归版 #include<stdio.h> #include<string.h> const int inf = 0x0fffffff; #define min(x, y)(x < y ? x : y) #define low(x, y)((x == '(' && y == ')') || (x == '[' && y == ']')) char str[110]; int dp[110][110]; int fun(int x,int y) { if(dp[x][y] != -1) return dp[x][y]; if(x > y)return 0; if(x == y)return 1; int ans = inf; if(low(str[x], str[y])) ans = min(ans, fun(x + 1, y - 1)); for(int i = x;i < y; ++ i) ans = min(ans, fun(x, i) + fun(i + 1, y)); dp[x][y] = ans; return ans; } int main() { int T; scanf("%d", &T); while(T --) { scanf("%s", str); int len = strlen(str); memset(dp, -1, sizeof(dp)); printf("%d ", fun(0, len - 1)); } }
参考：http://blog.acmj1991.com/?p=1142
http://www.dewen.org/q/8653/%E4%B8%80%E4%B8%AA%E6%8B%AC%E5%8F%B7%E5%8C%B9%E9%85%8D%E7%9A%84%E6%89%A9%E5%B1%95%E9%97%AE%E9%A2%98
另一题：
输入括号的数目，输出括号的各种合法匹配样式
输入 2
输出
(（））
（）（）
据说这是一道某公司的面试题，我们先来分析一下。括号匹配有合法有的不合法 如 （（）））（ 这样就不是合法的匹配样式。为了避免这种情况的出现，记录当前左括号的个数和右括号的个数，使右括号的个数不大于左括号的个数。主要思想类似于0-1背包问题，当进行到某一步的时候 有两种方法：放'（' 和 放 '）'
void matching(int left,int right,int sum,vector<char> bracket) { if (left==sum&&right==sum) //如果左边和右边都为要匹配的个数，则输出结果 { vector<char>::iterator iter=bracket.begin(); for ( ;iter!=bracket.end();iter++) { cout<<*iter<<' '; } cout<<endl; return ; } if (left<=sum) { bracket.push_back('('); //放入左括号，然后递归 matching(left+1,right,sum,bracket); bracket.pop_back(); //递归后弹出左括号 } if (left>right&&left<=sum) { bracket.push_back(')'); matching(left,right+1,sum,bracket); bracket.pop_back(); } } int main(int argc, char* argv[]) { vector<char> bracket; //记录当前的匹配样式 int num; cin>>num; //输入括号的个数 matching(0,0,num,bracket); return 0; }
我最开始想的是回溯法，应该和八皇后问题思路一致。但这个程序不是。上面递归程序不好理解。
可以举个例子:sum=3时，
最开始一值是运行第二个递归:
(((,
接着:
放入一个),接着递归,又放入一个),又放入); 最后变成了:
((()));
输出这个之后。
有2n个人排成一队进入剧场。入场费5元。其中只有n个人有一张5元钞票，另外n人只有10元钞票，剧院无其它钞票可找零，问有多少中方法使得只要有10元的人买票，售票处就有5元的钞票找零？(将持5元者到达视作将5元入栈，持10元者到达视作使栈中某5元出栈)。
对于这个例子，剧院要想总有零钱可找，那么目前进入剧院的人数中，揣着10元钞票的人数必须少于等于揣着5元钞票的，不然肯定在某个人那出现没零钱找的情况。
现在回到正题上来对于一个给定入栈序列，怎么求它的出栈序列呢？
我们可以把入栈记为1，出栈记为0.那么前缀子序列中1的个数必须大于等于0的个数，即入栈次数要大于等于出栈次数,如1 1 0 1 0 0，它的任意前缀序列中1的个数是大于等于0的个数的。
我们来看个例子:对于1 2 3这个入栈序列，1 1 0 1 0 0就是一个入栈出栈序列，第一个1代表元素1入栈，然后第二个1代表元素2入栈，然后第三个是0，代表出栈，即元素2出栈，然后第四个是1，代表元素3入栈，然后第五个是0，代表出栈，即元素3出栈，然后第六个是0，代表元素1出栈。最后1 1 0 1 0 0就代表了出栈序列2 3 1。
那么现在的问题就转换为如何求出所有符合条件的0 1序列了。其实这和以下问题相同:给定括号对数，输出所有符合要求的序列。如2对括号，输出有()()或者(())两种。1可以看成'('，0可以看成‘)’。
下面贴上本人的程序，并给出详细注释。
#include <iostream>
#include <vector>
using namespace std;
void func(vector<char>kind,int count[],int n)
{
if(count[0]>=1)
{
kind.push_back('(');
count[0]--;
func(kind,count,n);
count[0]++;
kind.pop_back();
}
if((count[1]>=1) && (count[1]>count[0]))
{
kind.push_back(')');
count[1]--;
func(kind,count,n);
count[1]++;
kind.pop_back();
}
if(kind.size()==2*n)
{
vector<char>::iterator iter;
for(iter=kind.begin();iter!=kind.end();iter++)
{
cout<<(*iter)<<" ";
}
cout<<endl;
}
}
int main()
{
int n;
cout << "please input the number of ():" << endl;
cin>>n;
int count[2]={n-1,n};
vector<char>kind;
kind.push_back('(');
func(kind,count,n);
return 0;
}
count[0]存着左括号数目，count[1]存着右括号数目。一开始kind中压入左括号，因为第一个肯定是左括号。然后count数组初始化为n-1个左括号，n个右括号。然后我们递归的处理。如果剩余左括号数count[0]大于0，就可以把左括号压栈。而对于右括号，栈中左括号个数必须多于右括号个数，也就是剩余右括号个数大于左括号个数，即count[1]>count[0]时，才能将右括号压栈。如果栈中元素个数达到2n时，就把栈中元素输出。
下面贴出出栈序列代码，几乎和上面相同。
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
int number=0;
void func(vector<int>kind,int count[],int n,int A[])
{
if(count[0]>=1)
{
kind.push_back(1);
count[0]--;
func(kind,count,n,A);
count[0]++;
kind.pop_back();
}
if((count[1]>=1) && (count[1]>count[0]))
{
kind.push_back(0);
count[1]--;
func(kind,count,n,A);
count[1]++;
kind.pop_back();
}
if(kind.size()==2*n)
{
vector<int>::iterator iter;
stack<int>stk;
int j=0;
for(iter=kind.begin();iter!=kind.end();iter++)
{
//cout<<(*iter)<<" ";
if(1==(*iter))
{
stk.push(A[j]);
j++;
}
else
{
cout<<stk.top()<<" ";
stk.pop();
}
}
number++;
cout<<endl;
}
}
int main()
{
int n,i;
cout << "please input the number:" << endl;
cin>>n;
int A[n];
cout << "please input the push sequence:" << endl;
for(i=0;i<n;i++)
{
cin>>A[i];
}
int count[2]={n-1,n};
vector<int>kind;
kind.push_back(1);
cout<<"the result is:"<<endl;
func(kind,count,n,A);
cout<<"total:"<<number<<endl;
return 0;
}
参考：http://blog.csdn.net/zz198808/article/details/7585385
一篇文章：
#include<iostream> #include<stack> using namespace std; static int counter; void outprint(stack<int> q){ while (q.size() != 0) { cout << q.top() << "-> "; q.pop(); } cout << endl; counter++; return; } //q 存放入栈序列 //stk 用于模拟入栈过程 //output 用于存放可能的出栈序列 void allPopSeq(stack<int> q,stack<int> stk,stack<int> output){ if((q.size() == 0)&&(stk.size()==0)&&(output.size() == 5)) { outprint(output); return; } if(q.size()!=0){//入栈 int v = q.top(); stk.push(v); q.pop(); allPopSeq(q,stk,output); stk.pop(); q.push(v);//回溯恢复 } if(stk.size()!=0) //出栈 { int v = stk.top(); stk.pop(); output.push(v); allPopSeq(q,stk,output); output.pop(); stk.push(v);//回溯恢复 } return; } int main() { int arr[5] = { 1, 2, 3, 4, 5 }; stack<int> stkValues; stack<int> stkOutput; stack<int> tmp; int i; for (i = 0; i != 5; ++i){ stkValues.push(arr[i]); } allPopSeq(stkValues, tmp, stkOutput); cout << counter << endl; }
http://www.cnblogs.com/fxplove/articles/2500898.html
程序员面试题精选100题(24)－栈的push、pop序列[数据结构]
题目：输入两个整数序列。其中一个序列表示栈的push顺序，判断另一个序列有没有可能是对应的pop顺序。为了简单起见，我们假设push序列的任意两个整数都是不相等的。
比如输入的push序列是1、2、3、4、5，那么4、5、3、2、1就有可能是一个pop系列。因为可以有如下的push和pop序列：push 1，push 2，push 3，push 4，pop，push 5，pop，pop，pop，pop，这样得到的pop序列就是4、5、3、2、1。但序列4、3、5、1、2就不可能是push序列1、2、3、4、5的pop序列。
分析：这到题除了考查对栈这一基本数据结构的理解，还能考查我们的分析能力。
这道题的一个很直观的想法就是建立一个辅助栈，每次push的时候就把一个整数push进入这个辅助栈，同样需要pop的时候就把该栈的栈顶整数pop出来。
我们以前面的序列4、5、3、2、1为例。第一个希望被pop出来的数字是4，因此4需要先push到栈里面。由于push的顺序已经由push序列确定了，也就是在把4 push进栈之前，数字1，2，3都需要push到栈里面。此时栈里的包含4个数字，分别是1，2，3，4，其中4位于栈顶。把4 pop出栈后，剩下三个数字1，2，3。接下来希望被pop的是5，由于仍然不是栈顶数字，我们接着在push序列中4以后的数字中寻找。找到数字5后再一次push进栈，这个时候5就是位于栈顶，可以被pop出来。接下来希望被pop的三个数字是3，2，1。每次操作前都位于栈顶，直接pop即可。
再来看序列4、3、5、1、2。pop数字4的情况和前面一样。把4 pop出来之后，3位于栈顶，直接pop。接下来希望pop的数字是5，由于5不是栈顶数字，我们到push序列中没有被push进栈的数字中去搜索该数字，幸运的时候能够找到5，于是把5 push进入栈。此时pop 5之后，栈内包含两个数字1、2，其中2位于栈顶。这个时候希望pop的数字是1，由于不是栈顶数字，我们需要到push序列中还没有被push进栈的数字中去搜索该数字。但此时push序列中所有数字都已被push进入栈，因此该序列不可能是一个pop序列。
也就是说，如果我们希望pop的数字正好是栈顶数字，直接pop出栈即可；如果希望pop的数字目前不在栈顶，我们就到push序列中还没有被push到栈里的数字中去搜索这个数字，并把在它之前的所有数字都push进栈。如果所有的数字都被push进栈仍然没有找到这个数字，表明该序列不可能是一个pop序列。
基于前面的分析，我们可以写出如下的参考代码：
#include <stack> ///////////////////////////////////////////////////////////////////////////// // Given a push order of a stack, determine whether an array is possible to // be its corresponding pop order // Input: pPush - an array of integers, the push order // pPop - an array of integers, the pop order // nLength - the length of pPush and pPop // Output: If pPop is possible to be the pop order of pPush, return true. // Otherwise return false ///////////////////////////////////////////////////////////////////////////// bool IsPossiblePopOrder(const int* pPush, const int* pPop, int nLength) { bool bPossible = false; if(pPush && pPop && nLength > 0) { const int *pNextPush = pPush; const int *pNextPop = pPop; // ancillary stack std::stack<int> stackData; // check every integers in pPop while(pNextPop - pPop < nLength) { // while the top of the ancillary stack is not the integer // to be poped, try to push some integers into the stack while(stackData.empty() || stackData.top() != *pNextPop) { // pNextPush == NULL means all integers have been // pushed into the stack, can't push any longer if(!pNextPush) break; stackData.push(*pNextPush); // if there are integers left in pPush, move // pNextPush forward, otherwise set it to be NULL if(pNextPush - pPush < nLength - 1) pNextPush ++; else pNextPush = NULL; } // After pushing, the top of stack is still not same as // pPextPop, pPextPop is not in a pop sequence // corresponding to pPush if(stackData.top() != *pNextPop) break; // Check the next integer in pPop stackData.pop(); pNextPop ++; } // if all integers in pPop have been check successfully, // pPop is a pop sequence corresponding to pPush if(stackData.empty() && pNextPop - pPop == nLength) bPossible = true; } return bPossible; }
http://zhedahht.blog.163.com/blog/static/25411174200732102055385/
或者判断出栈序列是否合法
输入两个整形序列，*put,*out,分别表示入栈和出栈，判断出栈是否符和入栈要求。
参考：
http://blog.163.com/m13591120447_1/blog/static/21637918920132270746190/