括号匹配

括号匹配的检验

问题很简单，即给出一串由 { } [ ] ( ) 和其他字符组成的表达式，能够判断该表达式中各括号层次是否合法

问题分析

即给出一字符串，首先过滤其他字符，然后在算法中设置一个栈，每读入一个括号

1. 若是右括号，栈顶的左括号与其匹配则栈，或者是不合法的情况
2. 若是左括号，则入栈
3. 栈空结束

如：{ [ ] ( ) } \ [ ( ( ) ) { } ] 均为正确实例

以 [ ( ] ) 为例

1. [ 入栈
2. ( 入栈
3. ] 与栈顶的 （ 不匹配则不合法

概要设计

顺序表

typedef struct LIST{ 
	ElemType *elem;
	int length;
	int listsize;
}List;//顺序表 

栈

typedef struct{
	ElemType *base;//栈构造前和销毁后为NULL 
	ElemType *top;//栈顶指针 
	int stacksize;//当前已分配的存储空间 
}SqStack,* link; 

详细设计

主函数

int main(){
	List Exp;
	InitList(&Exp);
	Create(&Exp);
	//PrintList(Exp);
	if(Judge_Brackets(Exp) == 0)
		printf("\n括号配对错误！\n");
	else
		printf("\n括号配对正确！\n");
}

顺序表

void PrintList(List L){				//输出顺序表 
	
		for(int i=0;i<L.length;i++)
		printf("%c ",L.elem[i]);
		printf("\n");
}

Status InitList(List*L){		//初始化一张表 
	
		L->elem = (ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));//分配内存distribute memory
		if(!L->elem)	 
			exit(OVERFLOW);
		L->length = 0;
		L->listsize = LIST_INIT_SIZE;
		return OK; 
}//InitList_SqList

void Create(List *L){
	     char ch;
	     printf("创建一个顺序表！\n");
		 scanf("%c",&ch);
	     while(ch !='\n'){
		    	L->elem[L->length] = ch;
			    L->length++;
		scanf("%c",&ch);
	 }
}

顺序栈

int StackEmpty(SqStack s)
{
	if(s.base==s.top)
		return TRUE;
	else
		return FALSE;
}

Status InitStack(SqStack *S){
	S->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));     //分配存储空间
	if(!S->base)
		exit(OVERFLOW);     //存储分配失败 
	S->top = S->base;     //栈顶等于栈底
	S->stacksize = STACK_INIT_SIZE;
	return OK;
}

Status Push(link s,ElemType e)
{
	//插入元素e为新的栈顶元素 
    if(s->top-s->base>s->stacksize)
    {
        s->base=(ElemType*)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(ElemType));
        if(!s->base) exit (OVERFLOW);
        s->top=s->base+s->stacksize;
        s->stacksize+=STACKINCREMENT;
    }
    *s->top++=e;
    return OK;
}


Status Pop(link s,ElemType &e)
{
	//若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK，否则返回ERROR 
	if(s->top == s->base)return ERROR;
	e = *--s->top;
	return OK; 
}

核心函数

int Judge_Brackets(List L){

	link S;     //定义一个栈，并初始化
	InitStack(S);
	ElemType ch;     //定义一个ch存取括号
	for(int i = 0;i < L.length;i++){
		//为左括号则入栈 
		if(L.elem[i] == '(' || L.elem[i] == '[' || L.elem[i] == '{'){
			ch = L.elem[i];
			Push(&S,ch);
		}
		//右括号 
		else if(L.elem[i] == ')'){
			if(S->base == S->top)
				return 0;
			Pop(S,ch);     //出栈顶元素，并删除
			if(ch != '('){     //比较
				return 0;
			}	
		}
		else if(L.elem[i] == ']'){
			if(S->base == S->top)
				return 0;
			Pop(S,ch);     //出栈顶元素，并删除
			if(ch != '['){     //比较
				return 0;
			}	
		}
		else if(L.elem[i] == '}'){
			if(S->base == S->top)
				return 0;
			Pop(S,ch);     //出栈顶元素，并删除
			if(ch != '{'){     //比较
				return 0;
			}
		}
	}
	if(S->base != S->top)
		return 0;
	else 
		return 1;
}

我想说

栈是一个先进后出的线性表，利用该点可以很好的解决该类问题