数据结构(栈&队)：括号匹配，后缀表达式求值，栈队操作。

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#define MAXSIZE 30
#define OK 1
#define OVERFLOW 0
#define ERROR 0
#define MAXQSIZE 30
typedef int Status;
//栈的定义 （字符栈）
typedef struct StackNode
	{
		char data;
		struct StackNode *next;
	}StackNode,*LinkStack;
	//栈的初始化 （字符栈）
Status InitStack(LinkStack &S)
	{
		S=NULL;
		return OK;
	} 
//判断栈是否为空（字符栈）
int StackEmpty(LinkStack S)
	{
		if(S==NULL)return 1;
		return 0;
 	} 
//入栈 （字符栈）
Status Push(LinkStack &S,char e)
	{
		LinkStack p;
   	 p=(LinkStack)malloc(sizeof(StackNode));
		p->data=e;
		p->next=S;
		S=p;
		return OK;
	}
//出栈 （字符栈）
Status Pop(LinkStack &S,char e)
	{
		LinkStack p;
		if(S==NULL) return ERROR;
		e=S->data;
		p=S;
		S=S->next;
		delete p;
		return OK;
	}
//取出栈顶元素 （字符栈）
char GetTop(LinkStack S)
	{
		if(S!=NULL)
			return S->data;
	}	
//栈的定义 （实数栈）
typedef struct StackNode1
	{
		float data;
		struct StackNode1 *next;
	}StackNode1,*LinkStack1;
//栈的初始化 （实数栈）
Status InitStack1(LinkStack1 &S)
	{
		S=NULL;
		return OK;
	} 
//判断栈是否为空（实数栈）
int StackEmpty1(LinkStack1 S)
	{
		if(S==NULL)return 1;
		return 0;
	 } 
//入栈 （实数栈）
Status Push1(LinkStack1 &S,float e)
	{
		LinkStack1 p;
    	p=(LinkStack1)malloc(sizeof(StackNode1));
		p->data=e;
		p->next=S;
		S=p;
		return OK;
	}
//出栈 （实数栈）
Status Pop1(LinkStack1 &S,float e)
	{
		LinkStack1 p;
		if(S==NULL) return ERROR;
		e=S->data;
		p=S;
		S=S->next;
		delete p;
		return OK;
	}

//取出栈顶元素（实数栈） 
float GetTop1(LinkStack1 S)
	{
		if(S!=NULL)
			return S->data;
	}
//循环队列定义
typedef struct
	{
		float *base;
			int front;
		int rear; 
 	} 	SqQueue;
//循环队列的初始化
Status InitQueue(SqQueue &Q)
	{
		Q.base=new float[MAXQSIZE];
		if(!Q.base) exit(OVERFLOW);
		Q.front=Q.rear=0;
		return OK;
 	} 
 //入队
 Status EnQueue(SqQueue &Q,float e)
 	{
 		if((Q.rear+1)%MAXQSIZE==Q.front)
 		return ERROR;
 		Q.base[Q.rear]=e;
 		Q.rear=(Q.rear+1)%MAXQSIZE;
 		return OK;
 	 } 
 //出队
 Status DeQueue(SqQueue &Q,float &e)
	 {
 		if(Q.front==Q.rear) return ERROR;
 		e=Q.base[Q.front];
 		Q.front=(Q.front+1)%MAXQSIZE;
 		return OK;
  	} 
  //取循环队列的对头元素
float GetHead(SqQueue Q)
 	{
 		if(Q.front!=Q.rear)
 			return Q.base[Q.front];
  	} 
  //判断循环队列是否为空
int pankong(SqQueue Q)
  	{
  		if(Q.front==Q.rear) return 1;
  			return 0;
  	 } 
//判断符号是否匹配 
Status Matching(char b[],int num)
	{
		int i=0,k=0;
		char e,o;
		LinkStack S;
		InitStack(S);
		int flag=1;
		while(i<num&&flag)
	{
		switch(b[i])
		{
		case'[':
		case'(':
		case'{':
			Push(S,b[i]);
			k++;
			break;
		case')':
			if(!StackEmpty(S)&&GetTop(S)=='(')
				Pop(S,b[i]);
			else
				{
					flag=0;
					o=')';
				}	
			k++;
			break;
		case']':
			if(!StackEmpty(S)&&GetTop(S)=='[')
				Pop(S,b[i]);
			else 
			{
				flag=0;
				o=']';
			}
			k++;
			break;
		case'}':
			if(!StackEmpty(S)&&GetTop(S)=='{')
				Pop(S,b[i]);
			else 
			{
				flag=0;
				o='}';
			}
			k++;
		}
		i++;
	}
	if(StackEmpty(S)&&flag) 
	{
	printf("\n匹配成功\n");
	return true;
	}
	else 
	{
		if(!StackEmpty(S))
		o=GetTop(S);
	printf("\n\n第一次错误位置处为：第%d个括号字符 %C 匹配失败\n",k,o);
	return false;
	}
	 
}
// 计算后缀表达式
float calcExp(char exp[],int num)
  {
	 LinkStack1 S1;
	 InitStack1(S1);  
     int i=0;
	 float n,m;
   	 while(exp[i] != '#')
   	{
      	if(exp[i]>='0' && exp[i]<='9')
        	{
			Push1(S1,float(exp[i]-'0'));
			
			}

		else {	m=GetTop1(S1);
            Pop1(S1,m);
            n=GetTop1(S1);
            Pop1(S1,n);
            if(exp[i] == '-')
        		{
        	
           		 Push1(S1,n-m);
       			}
       		 else if(exp[i] == '+')
       			 {
        
           		 Push1(S1,n+m);
        		}
       		 else if(exp[i] == '/')
        		{
        
          		  Push1(S1,n/m);
        		}
        	else if(exp[i] == '*')
       		{
       	 	
        	
            Push1(S1,n*m);
        }
			
			
        }
        i++;
    }
 
    printf("\n\n");
    return GetTop1(S1);
}
//顺序队列将指定堆栈中的元素删除 
int w3(float n[],int num)
{
	int a;
	LinkStack1 S3;
	InitStack1(S3);
	LinkStack1 S5;
	InitStack1(S5); 
	SqQueue S4;
	InitQueue (S4);
	int i=0;
	float v,d,f,p;
	while(i<num)
    {
    	Push1(S3,float(n[i]));
    	i++;
	}
	do{
	printf("\n请输入你想删除的元素");
	scanf("%f",&f);
	while(!StackEmpty1(S3))
	{
		v=GetTop1(S3);
	if(v==f)
		{
		Pop1(S3,d);
		}
	else 
		{
			
		EnQueue(S4,v);
		Pop1(S3,d);
		}
	}
	while(!pankong(S4))
	{
		float m;
		f=GetHead(S4);
		DeQueue(S4,m);
		Push1(S5,m);
	}
	int j=0;
	float k[j];
	while(!StackEmpty1(S5))
	{	
		k[j]=GetTop1(S5);
		Pop1(S5,f);
		j++;
	}
	printf("\n删除元素后站的元素为：");
	int kk=0;
	while(kk<j)
	{
		printf("%g  ",k[kk]);
		kk++;
	}
	int ll=0;
	while(ll<kk)
	{
		Push1(S3,k[ll]);
		ll++;
	}
	printf("\n请输入要操作的类型\n1继续删除元素\n2清空栈退出\n");
	scanf("%d",&a); 
		if(a==2)
		{
			while(!StackEmpty1(S3))
			{
				float t;
				Pop1(S3,t);
			}
			printf("\n清除完毕\n");
		}
}while(a==1);
		printf("\n请输入要操作的功能\n1括号是否匹配 ");
		printf("\n2后缀表达式求值\n3顺序队列删除栈中的元素\n\n");
}
//主函数 
int main() 
{
	int L;
	printf("\n请输入要操作的功能\n1括号是否匹配 ");
	printf("\n2后缀表达式求值\n3顺序队列删除栈中的元素\n\n");	
do{
	scanf("%d",&L);
	char c,a[MAXSIZE];
	int num=0,num1=0,i=0;
	if (L==1)
	{
	printf("请在英文状态下输入一串由括号组成的字符串，以#结尾，按回车结束！\n");
	scanf("%c",&c);
	while(c!='#')
	{
		if(c=='('||c==')'||c=='['||c==']'||c=='{'||c=='}')
		{
			a[num]=c;
			num++;
		}
		scanf("%c",&c);
	} 
	printf("\n你输入的字符串为：");
	while(i<num)
	{
		printf("%c",a[i]);
		i++;
	}
	Matching(a,num);
	printf("\n请输入要操作的功能\n1括号是否匹配 ");
	printf("\n2后缀表达式求值\n3顺序队列删除栈中的元素\n\n");
	}
	else if(L==2)
	{
	printf("请输入后缀表达式，以#结尾，按回车结束！\n\n");
	scanf("%c",&c);
	while(c!='#')
	{
		if(c>='0'||c<='9'||c=='-'||c=='+'||c=='*'||c=='/')
		{
			a[num]=c;
			num++;
		}
		scanf("%c",&c);
	}
			a[num]='#';
			num++;
	printf("\n你输入的后缀表达式为：");
	while(i<num)
	{
		printf("%c",a[i]);
		i++;
	}
	float s;
	s=calcExp(a,num);
	printf("后缀表达式计算结果为s=%g\n",s);
	printf("\n请输入要操作的功能\n1括号是否匹配 ");
	printf("\n2后缀表达式求值\n3顺序队列删除栈中的元素\n\n");
	}
	else if (L==3)
	{
		float c;
		float m[MAXSIZE];
		printf("请输入一个实数数组，以999结尾，按回车结束！\n");
	scanf("%f",&c);
	while(c!=999)
	{ 
		m[num1]=c;
		num1++;
		scanf("%f",&c);
	}
	printf("\n你输入的字符串为：");
	while(i<num1)
	{
		printf("%g  ",m[i]);
		i++;
	}
	w3(m,num1);
	}
	}while(L); 
 }