括号匹配（基于链栈）

括号匹配只需要在链栈的基础上增加括号匹配函数：

void matching(Stack *st);//括号匹配
int Match(ElemType e,ElemType ch);

函数如下：

int Match(ElemType e,ElemType ch)
{
	if(e == '(' && ch == ')')
	{
		return 1;
	}
	else if(e == '[' && ch == ']')
	{
		return 1;
	}
	else if(e == '{' && ch == '}')
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

void matching(Stack *st)
{
	char *p;
	ElemType e;
	ElemType ch[100];
	InitStack(st);
	cout<<"请输入带括号的表达式('{}','[]','()')"<<endl;
	gets(ch);
	p = ch;
	while(*p)//单个字符处理
	{
		switch(*p)
		{
		case '(':
		case '[':
		case '{':
			push(st,*p++);
			break;
		case ')':
		case ']':
		case '}':
			if(StackEmpty(st))
			{
				cout<<"缺少左括号"<<endl;
				return;
			}
			else
			{
				e = GetTop(st);
				if(Match(e,*p))
				{
					pop(st);
				}
				else
				{
					cout<<"左右括号不配对"<<endl;
					return;
				}
			}
		default:
			p++;
		}
	}
	if(StackEmpty(st))
	{
		cout<<"左右括号配对"<<endl;
	}
	else
	{
		cout<<"缺少右括号"<<endl;
	}
}

具体函数如下：

头文件：

#ifndef _STACK_H
#define _STACK_H

#include<iostream>
#include<assert.h>
using namespace std;

#define ElemType char

typedef struct Node
{
	ElemType data;
	struct Node *next;
}Node,*PNode;

typedef struct Stack
{
	PNode top;
	PNode rear;
	size_t size;
}Stack;

int StackEmpty(Stack *st);
void InitStack(Stack *st);//初始化
bool push(Stack *st,ElemType x);//尾插
bool pop(Stack *st);//头删
void ShowStack(Stack *st);//打印
void clear(Stack *st);//清除
void destroy(Stack *st);//摧毁
int length(Stack *st);//长度
ElemType GetTop(Stack *st);//栈顶元素
void matching(Stack *st);//括号匹配
int Match(ElemType e,ElemType ch);

#endif

函数定义函数：

#include "Stack.h"

int StackEmpty(Stack *st)
{
	if(st->size == 0)
	{
		return 1;
	}
	return 0;
}

void InitStack(Stack *list)//初始化
{
	Node* s = (Node*)malloc(sizeof(Node));
	assert(s != NULL);
	s->next = NULL;
	list->rear = list->top = s;
	list->size = 0;
}

bool push(Stack *st, ElemType x)//尾插
{
	Node *p = (Node*)malloc(sizeof(Node));
	assert(p != NULL);
	p->data = x;
	p->next = st->top->next;
	st->top->next = p; 
	st->size++;
	return true;
}

void ShowStack(Stack *st)//打印
{
	Node *p = st->top->next ;
	cout<<"NULL"<<endl;
	while(p != NULL)
	{
		cout<<p->data <<endl;
		p = p->next ;
	}
}

bool pop(Stack *st)//头删
{
	if(StackEmpty(st))
	{
		cout<<"栈已空，不能出栈！"<<endl;
		return false;
	}
	Node *p = st->top->next;
	if(st->size == 1)
	{
		free(p);
		st->top->next = NULL;
		st->rear = st->top;
	}
	else
	{
		st->top->next = p->next ;
		free(p);
	}
	st->size--;
	return true;
}

ElemType GetTop(Stack *st)//栈顶元素
{
	if(StackEmpty(st))
	{
		printf("栈已空，没有栈顶元素！\n");
		return -1;
	}
	return st->top->next->data;
}
void clear(Stack *st)//清除
{
	Node *p = st->top->next;
	while(p != NULL)
	{
		st->top->next = p->next;
		free(p);
		p = st->top->next;
	}
	st->rear  = st->top ;
	st->size  = 0; 
}

void destroy(Stack *st)//摧毁
{
	clear(st);
	free(st->top);
	st->top = st->rear = NULL;
}

int length(Stack *st)//长度
{
	return st->size ;
}

int Match(ElemType e,ElemType ch)
{
	if(e == '(' && ch == ')')
	{
		return 1;
	}
	else if(e == '[' && ch == ']')
	{
		return 1;
	}
	else if(e == '{' && ch == '}')
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

void matching(Stack *st)
{
	char *p;
	ElemType e;
	ElemType ch[100];
	InitStack(st);
	cout<<"请输入带括号的表达式('{}','[]','()')"<<endl;
	gets(ch);
	p = ch;
	while(*p)//单个字符处理
	{
		switch(*p)
		{
		case '(':
		case '[':
		case '{':
			push(st,*p++);
			break;
		case ')':
		case ']':
		case '}':
			if(StackEmpty(st))
			{
				cout<<"缺少左括号"<<endl;
				return;
			}
			else
			{
				e = GetTop(st);
				if(Match(e,*p))
				{
					pop(st);
				}
				else
				{
					cout<<"左右括号不配对"<<endl;
					return;
				}
			}
		default:
			p++;
		}
	}
	if(StackEmpty(st))
	{
		cout<<"左右括号配对"<<endl;
	}
	else
	{
		cout<<"缺少右括号"<<endl;
	}
}

测试函数

#include "Stack.h"

void main()
{
	Stack mystack;
	InitStack(&mystack);
	matching(&mystack);
}

此函数对于一个字符串进行括号匹配操作，操作简单，且测试容易，故不进行执行截图。希望大家能够提出建议，谢谢。

在最近学习中，发展可以不使用switch即可完成括号匹配操作，具体代码如下：

bool Check(const char *str)
{
	Stack st;                            //定义栈
	InitStack(&st);                      //初始化
	while(*str != '\0')                  //字符串结束标志
	{ 
	  	if(*str == '[' || *str == '(')   //为左括号
		{
			push(&st,*str);              //入栈
		}
		else if(*str == ']')             //分别判断
		{
			if(GetTop(&st) != '[')       //是否匹配
			{
				return false;
			}
			else
			{
				pop(&st);                 //匹配出栈
			}
		}
		else if(*str == ')')              //同上
		{
			if(GetTop(&st) != '(')
			{
				return false;
			}
			else
			{
				pop(&st);
			}
		}
		str++;                            //字符指针后移
	}
	return StackEmpty(&st);               //判断栈是否为空，为空即匹配成功
}