假设表达式中允许包含三种括号：圆括号和方括号和大括号，其嵌套的顺序随意，即( [ ] ( ) )或者[ ( [ ] ) ]为正确格式，[(])或(()]均为不正确的格式，检验括号是否匹配的方法可用”期待的破却程度”来描述。

下面来对括号是否匹配来进行检验

对于检验括号是否匹配可以对其进行进栈和出栈来处理，遇到’ ( ‘、’ [ ‘、‘ { ’时对其进栈，遇到’)’、‘]’、‘}’对其出栈，在算法的开始结束的时候栈都应该是空的，每次遇到右括号出栈的时候都应该要有一个相同括号的左括号与其匹配，不然则视其出栈失败即括号不匹配

【（【】【】）】

例如上面一开始是1,2,3是左括号，那么从左往右开始进栈，栈底元素是1,2,3，当遇到第4个右括号的时候，堆栈进行出列，这时候出列的符号应该与4符号对应的左括号3，第3个括号出列，此时栈中只剩下1,2，遇到第5个括号时因为是左括号所以进栈，栈中元素是1,2,5，剩下6,7,8方法也和上面的一样，遵循出列的括号要是与遇到右括号对其，只要在算法开始和结束的时候，栈都应该是空的那么括号就是正确格式！

检验括号匹配问题的函数算法：

Status Bracket(SqStack &S,char *str)
{
	int i=0;
	ElemType e;		//e是char类型 
	InitStack(S);		//构建一个空栈S 
	while(str[i]!='\0')
	{
		switch(str[i])
		{
			case '(':
				Push(S,str[i]);
				break;
			case '[':
				Push(S,str[i]);
				break;
			case '{':
				Push(S,str[i]);
				break;
			case ')':
				if(StackEmpty(S))		//如果是空栈那么无法进行出栈操作，符号不匹配 
					return ERROR;
				Pop(S,e);
				if(e!='(')				//如果与其左括号类型不匹配，符号也不匹配 
					return ERROR;
				break;
			case ']':
				if(StackEmpty(S))
					return ERROR;
				Pop(S,e);
				if(e!='[')
					return ERROR;
				break;
			case '}':
				if(StackEmpty(S))
					return ERROR;
				Pop(S,e);
			 	if(e!='{')
			 		return ERROR;
		 		break;
	 		default:
	 			break;
		}
		i++;
	}
	if(StackEmpty(S))
		return OK;			//开始和结束的时候，都为空栈那么返回OK表示符号匹配 
	else
		return ERROR;
}

嗯下面就是在VC中的测试：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -2
#define STACK_INIT_SIZE  100	//存储空间初始化分配量
#define STACKINCREMENT	 10		//存储空间分配增量 
typedef char ElemType;
typedef int Status;
typedef struct{
	ElemType	*base;			//栈底指针 
	ElemType	*top;			//栈顶指针 
	int 		stacksize;		
}SqStack;

Status InitStack(SqStack &s)
{//构建一个空栈S。 
	s.base=(ElemType*)malloc(STACK_INIT_SIZE*(sizeof(ElemType)));
	if(!s.base)
	{
		printf("建栈失败！\n");
		return ERROR; 
	}else{
		s.top=s.base;			//栈底和栈顶指针指向同一块内存 
		s.stacksize=STACK_INIT_SIZE;
		return OK; 
	}
}

Status DestroyStack(SqStack &s)
{//销毁栈s,s不再存在。 
	s.top=s.base;
	free(s.base);
	s.base=NULL;		//释放后一定要指向NULL，避免出现野指针 
	s.top=NULL;
	return OK;
}

Status ClearStack(SqStack &s)
{//将S清为空栈。 
	s.top=s.base;	//栈顶和栈底指针指向同一块内存此时栈中就没有其它元素 
	s.stacksize=0;	
	return OK;
}

Status StackEmpty(SqStack s)
{//若栈S为空栈，则返回TRUE，否则FALS。 
	if(s.top==s.base)
		return TRUE;
	else
		return FALSE;
}

Status StackLength(SqStack s)
{//返回S的元素个数，即栈的长度.。 
	return s.top-s.base;
}

Status GetTop(SqStack s,ElemType &e)
{//用e返回S的栈顶元素 。 
	if(StackEmpty(s))
	{
		printf("这是一个空栈！");
		return ERROR;
	}else{
		s.top--;
		e=*s.top;
		return OK;
	}
}

Status Push(SqStack &s,ElemType e)
{//插入元素e为新的栈顶元素。
	if(StackLength(s)==STACK_INIT_SIZE)
	{
		ElemType *temp=(ElemType*)realloc(s.base,(STACK_INIT_SIZE+STACKINCREMENT)*(sizeof(ElemType)));  
		if(!temp)
			return ERROR;
		s.base=temp;
		s.top=s.base+STACK_INIT_SIZE;
		s.stacksize=STACK_INIT_SIZE+STACKINCREMENT;
		*(s.top++)=e;
		return OK;
	}else{
		*s.top=e;
		s.top++;
		return OK; 
	}
}

Status Pop(SqStack &s,ElemType &e)
{//删除S的栈顶元素，并用e返回其值
	if(StackEmpty(s))
	{
	//	printf("这是一个空栈\n");
		return ERROR; 
	}else{
		e=*(--s.top);
		return OK;
	}
}


Status Bracket(SqStack &S,char *str)
{
	int i=0;
	ElemType e;		//e是char类型 
	InitStack(S);		//构建一个空栈S 
	while(str[i]!='\0')
	{
		switch(str[i])
		{
			case '(':
				Push(S,str[i]);
				break;
			case '[':
				Push(S,str[i]);
				break;
			case '{':
				Push(S,str[i]);
				break;
			case ')':
				if(StackEmpty(S))		//如果是空栈那么无法进行出栈操作，符号不匹配 
					return ERROR;
				Pop(S,e);
				if(e!='(')				//如果与其左括号类型不匹配，符号也不匹配 
					return ERROR;
				break;
			case ']':
				if(StackEmpty(S))
					return ERROR;
				Pop(S,e);
				if(e!='[')
					return ERROR;
				break;
			case '}':
				if(StackEmpty(S))
					return ERROR;
				Pop(S,e);
			 	if(e!='{')
			 		return ERROR;
		 		break;
	 		default:
	 			break;
		}
		i++;
	}
	if(StackEmpty(S))
		return OK;			//开始和结束的时候，都为空栈那么返回OK表示符号匹配 
	else
		return ERROR;
}

int main()
{ 
	SqStack S;
	char str[255];
	while(gets(str))
	{
		if(Bracket(S,str))
			printf("格式正确!\n");
		else
			printf("格式错误!\n");
		ClearStack(S); 		//清空栈中元素 
	}
	return 0;
}