数据结构顺序表顺序栈记录

#include<stdio.h>
#include<stdlib.h>
#define maxsize 100
typedef struct{          //顺序表
 int a[maxsize];
 int size;
}sequence_list;                                     //编译环境vs2010，function1为作业1算法，function2为作业2算法。
typedef struct{				//顺序栈
char a[maxsize];
int top;
}sequence_stack;
void init(sequence_list *slt)
{                       //顺序表初始化函数
	slt->size=0;
}
void append(sequence_list *slt,int x)
{
	if(slt->size==maxsize)            //顺序表append函数
	{printf("顺序表是满的！\n");exit(1);}
	slt->a[slt->size]=x;
	slt->size=slt->size+1;
}
void display(sequence_list slt)
{
	int i;
	if(!slt.a)
		printf("顺序表是空的！\n");		//顺序表显示函数
	else
		for(i=0;i<slt.size;i++)
			printf("%5d\n",slt.a[i]);
}
int empty(sequence_list slt)
{
	return(slt.size==0 ? 1:0);			//顺序表empty函数
}
int find(sequence_list slt,int x)
{
	int i=0;
	while(i<slt.size&&slt.a[i]!=x) i++;  //顺序表find函数
	return (i<slt.size? i:0);
}
int get(sequence_list *slt,int i)
{
	if(i<0||i>slt->size)
	{printf("指定位置不存在！\n");exit(1);}  //顺序表get函数
	else
		return slt->a[i-1];
}
void insert(sequence_list *slt,int x,int position)
{
	int i;
	if(slt->size==maxsize)
	{printf("顺序表已满，无法插入！\n");exit(1);}	//顺序表插入函数
	if(position<0||position>slt->size)
	{printf("指定位置非法，无法插入！\n");exit(1);}
	for(i=slt->size;i>position;i--)
		slt->a[i]=slt->a[i-1];
	slt->a[position]=x;
	slt->size++;
}
void del(sequence_list *slt,int position)
{
	int i;
	if(slt->size==0)				//顺序表删除函数
	{printf("顺序表是空的，无法删除！\n");exit(1);}
	if(position<0||position>=slt->size)
	{printf("指定位置不存在！\n");exit(1);}
	for(i=position;i<slt->size-1;i++)
		slt->a[i]=slt->a[i+1];
	slt->size--;
}
void function1(sequence_list *slt)
{
	int i,x=0;          //顺序表function1（作业1）
	for(i=1;i<slt->size;i++)
	{
		if(slt->a[i]<slt->a[0+x])
		{
			insert(slt,slt->a[i],0);
			del(slt,i+1);
			x++;
		}
	}
}
void function2(sequence_list *slt,sequence_list *list1,sequence_list *list2)
{
	int x,y,t=0;
	for(x=0;x<list1->size;x++) //顺序表function2（作业2）
		append(slt,list1->a[x]);
	for(y=0;y<list2->size;y++)
		append(slt,list2->a[y]);
	for(x=1;x<slt->size;x++)
		for(y=1;y<slt->size;y++)
			if(slt->a[y-1]>slt->a[y])
			{
				t=slt->a[y-1];
				slt->a[y-1]=slt->a[y];
				slt->a[y]=t;
			}
}
void init_stack(sequence_stack *st)		//顺序栈初始化函数
{
	st->top=0;
}
int empty_stack(sequence_stack *st)		//顺序栈empty函数
{
	return (st->top? 0:1);
}
char read_stack(sequence_stack *st)
{
	if(empty_stack(st))
	{printf("顺序栈是空的！");exit(1);}
	else
		return(st->a[st->top-1]);
}
void push_stack(sequence_stack *st,char x)		//顺序栈的压栈函数
{
	if(st->top==maxsize)
	{printf("顺序栈已满，无法插入！");exit(1);}
	st->a[st->top]=x;
	st->top++;
}
void pop_stack(sequence_stack *st)				//顺序栈弹栈函数
{
	if(st->top==0)
	{printf("顺序栈为空！");exit(1);}
	st->top--;
}
int match_kuohao(char c[])			//顺序栈应用于括号匹配的函数
{
	sequence_stack s;
	int sum=0;
	init_stack(&s);
	while(c[sum]!='#')
	{
	switch(c[sum])
	{
		case'{':
		case'[':
		case'(':push_stack(&s,c[sum]);break;
		case'}':if(!empty_stack(&s)&&read_stack(&s)=='{')
		{pop_stack(&s);break;}
				else return 0;
		case']':if(!empty_stack(&s)&&read_stack(&s)=='[')
		{pop_stack(&s);break;}
				else return 0;
		case')':if(!empty_stack(&s)&&read_stack(&s)=='(')
		{pop_stack(&s);break;}
				else return 0;
	}
	sum++;
	}
	return empty_stack(&s);
}

int main( int argc,char * argv[])
{
	int i,x,y;
	char zimu[10]={'{','[','(',')',']','}','#'};
	sequence_list abc;
	sequence_list list1;
	sequence_list list2;
	init(&abc);
	init(&list1);
	init(&list2);
	printf("请输入对顺序表C初始化数据数量：\n");
	scanf("%d",&i);										//顺序表c初始化赋值
	for(x=0;x<i;x++)
	{
		printf("输入第%d个数据\n",x+1);
		scanf("%d",&y);
		append(&abc,y);
	}
	printf("请输入对顺序表A初始化数据数量：\n");		//顺序表a初始化赋值
	scanf("%d",&i);		
	for(x=0;x<i;x++)
	{
		printf("输入第%d个数据\n",x+1);
		scanf("%d",&y);
		append(&list1,y);
	}
	printf("请输入对顺序表B初始化数据数量：\n");		//顺序表b初始化赋值
	scanf("%d",&i);		
	for(x=0;x<i;x++)
	{
		printf("输入第%d个数据\n",x+1);
		scanf("%d",&y);
		append(&list2,y);
	}
	function2(&abc,&list1,&list2);   //函数function2，作业2算法。(只需对顺序表A,B赋初值，无需对C赋初值)*/
	if(match_kuohao(zimu))
		printf("括号匹配成功！\n");
	else
		printf("括号匹配失败！\n");
	display(abc);
}

运行截图：