1:编写一个算法来判别表达式中的括号是否匹配，以字符"\0"作为算术表达式的结束符。（圆括号，花括号，中括号三种类型）

基本思想：

1）扫描每个字符，遇到花、中、圆的左括号进栈

2）遇到花、中、圆的右括号时检查栈顶元素是否为对应的左括号。若是，退栈，否则配对错误。

3）最后栈不为空也错误。

bool Check(char *str){
	stack<char> s;
	int i=0;
	char ch;
	while(str[i]!='\0'){
		switch(str[i]){
			//左括号入栈 
			case '(':s.push(str[i]);break;
			case '[':s.push(str[i]);break;
			case '{':s.push(str[i]);break;
			//遇到右括号，检测栈顶 
			case ')':ch=s.top();s.pop();
			   if(ch!='(') return false;
			   break;
			case ']':ch=s.top();s.pop();
			   if(ch!='[') return false;
			   break;
			case '}':ch=s.top();s.pop();
			   if(ch!='{') return false;
			   break;
			default:
			break;
		}//switch
	    i++;	
	}//while
	if(!s.empty()) return false;
	return true; 
}

2：用两个栈s1和s2模拟一个队列

算法思想：

1）对s2的出栈操作用作出队，若s2为空，则将s1的所有元素送入s2

2）对s1的入栈操作用作入队，若s1满，必须先保证s2空，才能将s1中的所有元素插入s2中

入队算法：

bool EnQueue(Stack &s1,Stack &s2,ElemType e){
	if(StackOverflow(s1) && !StackEmpty(s2)){
		printf("队列满");
		return false; 
	}
	if(!StackOverflow(s1)){
		push(s1,e);
		return true;
	}
	if(StackOverflow(s1) && StackEmpty(s2)){
		while(!StackEmpty(s1)){
			pop(s1,x);
			push(s2,x);
		}
	}
	push(s1,e);
	return true;
}

出队算法：

void DeQueue(Stack &s1,Stack &s, ElemType &x){
	if(!StackEmpty(s2)){
		pop(s2,x);
	}
	else if(StackEmpty(s1))
	     printf("队列为空"); 
	else{
		while(!StackEmpty(s1)){
			pop(s1,x);
			push(s2,x);
		}
		pop(s2,x);
	}
}

判空：

bool QueueEmpty(Stack &s1,Stack &s){
	if(StackEmpty(s1) && StackEmpty(s2))
	   return true;
	return false;
}

3：以I表示入栈，O表示出栈，栈的初态和终态都是空的，判断一个给定的IO序列是否合法

方法一：

1）逐一扫描序列，每扫描到‘O’字符，检查出入栈次数，若出栈次数大于入栈次数，则序列非法。

2）扫描结束后，再判断出入栈次数是否相等，若不等，则为非法序列。


bool Judge(char A[]){
	int i=j=k=0;
	while(A[i]!='\0'){
		switch(A[i]){
			case 'I':j++;break;
			case 'O':k++;
			  if(k>j) return false;
            break;
		}
		i++;
	}
	if(i!=k) return false;
	return true;
}

方法二：入栈加一，出栈减一，对序列的判断转化为对-1、1的判断。若任意前缀子序列累加和不小于0且最终序列和为0，则为合法序列，否则为非法序列。

4：共享栈

设有两栈s1、s2都采用顺序栈形式，并且共享一个存储区[0,...maxsize-1]，为了尽量利用空间，减少溢出可能，采用栈顶相向，迎面增长的存储方式。下面给出s1、s2有关入栈、出栈操作

数据结构：

#define maxsize 100
#define ElemType int
typedef struct{
	ElemType stack[maxsize];
	int top[2];
}stk;
stk s;

入栈：

bool input(int i,ElemType x){
	//i为栈号，i=0表示s1，i=1表示s2 
	if(i<0 || i>1) return false;//栈号不对 
	if(s.top[1]-s.top[1]==1){
		printf("栈满\n");
		return false; 
	}
	switch(i){
		case 0:s.stack[++s.top[0]]=x;return true;break;
		case 1:s.stack[++s.top[1]]=x;return true;break;
	}
}

出栈：

int output(int i){
	if(i<0 || i>1) return false;//栈号不对 
	switch(i){
		case 0:
			if(s.top[0]==-1){
				printf("栈空\n");
				return -9999;
			}
			else
				return s.stack[s.top[0]--];
		case 1:
			if(s.top[1]==maxsize){
				printf("栈空\n");
				return -9999;
			}
			else
			    return s.stack[s.top[1]--];
	}
}

栈和队列的简单应用