顺序栈与括号匹配

基本操作

1.栈的初始化

//栈的初始化
int InitiaStark(SqStark S)
{

	S->base=(int*)malloc(sizeof(int)*Maxsize);
	if(!S->base)
	{
		return 0;
	}
	
		S->top=S->base;
		S->stacksize=Maxsize;
	
	return 1;
}

2.判断是否为空

//判断栈是否为空
int Stackempty(SqStark S)
{
	if(S->top==S->base)
	return 1;//空栈 
	else
	return 0;
 } 

3.求元素个数

int Starkelemlength(SqStark S)
{
	if(S->base=S->top)
	return 0;
	else
	return (int)(S->top-S->base);
}

4.清空顺序栈

//清空顺序栈
int ClearStark(SqStark S)
{
	if(S->base)
	S->top=S->base;//这步很重要 
	return 1;
 } 

5.销毁顺序栈

//销毁顺序栈
int DestroyStark(SqStark S)
{
	if(S->base)
	{
		free(S->base);
		S->stacksize=0;
		S->top=S->base=NULL;
	}
	return 1;

6.顺序栈的入栈与出栈

//顺序栈的入栈
SqStark pushelem(SqStark S,int e)
{
	if(S->top-S->base>=S->stacksize)//判断是否栈满 
	return;
	*S->top=e;
	S->top++;
	return S;
 } 
 //顺序栈的出栈
SqStark popelem(SqStark S)
{
	if(S->top==S->base)
	return;//判断栈是否为空，若为空则不能在出栈
	int elem;
	S->top--;
	*S->top=elem;
	return S; 
 } 
 

7.完整代码

#include <stdio.h>
#include <stdlib.h>
#define Maxsize 5

typedef struct{
	int *top;//栈顶指针 
	int *base;//栈底指针 
	int stacksize;//表示栈可使用的最大容量 
}*SqStark; 

//栈的初始化
int InitiaStark(SqStark S)
{

	S->base=(int*)malloc(sizeof(int)*Maxsize);
	if(!S->base)
	{
		return 0;
	}
	
		S->top=S->base;
		S->stacksize=Maxsize;
	
	return 1;
}

//判断栈是否为空
int Stackempty(SqStark S)
{
	if(S->top==S->base)
	return 1;//空栈 
	else
	return 0;
 } 

//判断栈中元素个数
int Starkelemlength(SqStark S)
{
	int length=0;
	while(S->base!=S->top)
	{
		length++;
		S->base++;
	}

}
int Starkelemlength(SqStark S)
{
	if(S->base=S->top)
	return 0;
	else
	return (int)(S->top-S->base);
}

//清空顺序栈
int ClearStark(SqStark S)
{
	if(S->base)
	S->top=S->base;//这步很重要 
	return 1;
 } 
 
 //销毁顺序栈
int DestroyStark(SqStark S)
{
	if(S->base)
	{
		free(S->base);
		S->stacksize=0;
		S->top=S->base=NULL;
	}
	return 1;
 } 
 
 //顺序栈的入栈
SqStark pushelem(SqStark S,int e)
{
	if(S->top-S->base>=S->stacksize)//判断是否栈满 
	return;
	*S->top=e;
	S->top++;
	return S;
 } 
 //顺序栈的出栈
SqStark popelem(SqStark S)
{
	if(S->top==S->base)
	return;//判断栈是否为空，若为空则不能在出栈
	int elem;
	S->top--;
	*S->top=elem;
	return S; 
 } 
 
void printStark(SqStark S)
{
	int elem;
     while(S->base<S->top)
     {
     	elem=*S->base;
     	printf("%5d",elem);
     	S->base++;
	 }
	 printf("\n");
}
 
int main()
 {
 	SqStark S;
 	int result;
 	result=InitiaStark(S);
 	if(result==1)
 	printf("Success initia\n");
 	int i;
 	int elem;//要入栈的元素 
 	printf("please print the elems you want to push\n");
 	for(i=0;i<Maxsize;i++)
	 {
	 	scanf("%d",&elem);
	 	pushelem(S,elem);
	 }
	 printf("Success in pushing elems\n");
	 printf("The new stark is:\n");
	 printStark(S);
	 int result_1;
	 result_1=Stackempty(S);
	 if(result_1==1)
	 printf("The stark is empty\n");
 	 else
 	 printf("The stack is not empty\n");
 	 int result_2;
 	 result_2=Starkelemlength(S);
 	 printf("The elems in the stark is %d",result_2);
 	 S=popelem(S);
 	 printStark(S);
 	 int result_3;
 	 result_3= ClearStark(S);
 	 if(result_3==1)
 	 printf("Success clear\n");
 	 int result_4=DestroyStark(S);
 	 if(result_4==1)
     printf("Success destroy\n");
     return 0;
 }

说明：

栈就是操作受限制的线性表，它的删除与插入插做只能在栈顶进行，降低了时间复杂度。在写程序时要注意判断它栈空或栈满的情况，以免出错

括号匹配

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 10
typedef struct CharStack{
	int top;
	int data[MAXSIZE];
}*CharStackPtr;

/*typedef struct biaodshi{
	int a;//整数项 
	char b;//括号或运算符 
}biaodashi;*/
void printstack(CharStackPtr paraStack)
{
	int i;
	for(i=0;i<=paraStack->top;i++)
	{
		printf("%c",paraStack->data[i]);
	}
	printf("\r\n");
}

CharStackPtr charStackInit(){
	CharStackPtr resultPtr=(CharStackPtr)malloc(sizeof( CharStackPtr)*MAXSIZE);
	resultPtr->top =-1;
	return resultPtr;
}

void push(CharStackPtr paraStackPtr,int paraValue)
{
	if(paraStackPtr->top>=MAXSIZE-1)
	{
		printf("Cannot push the elem\r\n");
		return;
	}
	paraStackPtr->top++;
	paraStackPtr->data[paraStackPtr->top]=paraValue;
}

char pop(CharStackPtr paraStackPtr)
{
	if(paraStackPtr->top<0)//top指针指向负一表示栈空 
	{
		printf("Cannot pop the elem\r\n");
		return;
	}
	paraStackPtr->top--;
	return paraStackPtr->data[paraStackPtr->top+1]; 
}
CharStackPtr charStackInit();
int  ismatch(char *paraSting,int paraLength)//数组paraSting 
{
    CharStackPtr tempStack=charStackInit();
    push(tempStack,'#');
    char tempChar,tempPopedChar;
    
    int i;
    for(i=0;i<paraLength;i++)
    {
    	//scanf("%d%c",&paraSting[i].a,&paraSting[i].b);
    	tempChar=paraSting[i];
    	switch(tempChar){
    		case '(':
    		case '[':
    		case '{':
    		  {
    		  	push(tempStack,tempChar);
    		  	break;
			  }
		    case')':
		    	{
		    		tempPopedChar=pop(tempStack);
		    		if(tempPopedChar!='('){
		    			return 0;//不匹配 
					}
		    	break;	
				}
			case']':
				{
					tempPopedChar=pop(tempStack);
					if(tempPopedChar!='['){
						return 0;
					}
					break;
				}
			case'}':
			    {
			    	tempPopedChar=pop(tempStack);
				    if(tempPopedChar!='{'){
					
				     return 0;
				   }
				   break;	  
		}
		   default://比如一个表达式遇到了常数之类的 就不管它 
		   	break;
	}
   }
	tempPopedChar=pop(tempStack);
	if(tempPopedChar!='#')//说明匹配不成功，匹配成功最后只剩下# 
	{
		return 0;
	}
	return 1;
}
int main()
{
	int result;
	//CharStackPtr paraStack;
//	paraStack=charStackInit();
//	char paraSting[10];
	char *temp1Expression= "[2 + (1 - 3)] * }4)";
	char *temp2Expression= "{2 -1 *(8+9)}";
	char *temp3Expression= "[2 *9 +(2) +8) / 12 + 2";
	//int paraLength;
	//scanf("%d",&paraLength);
	int result1,result2,result3;
	result1=ismatch(temp1Expression,18);
	result2=ismatch(temp2Expression,13);
	result3=ismatch(temp3Expression,23);
	if(result1==1)
	printf("%s Success match\r\n",temp1Expression);
	else
	printf("%s Fail match\r\n",temp1Expression);
	if(result2==1)
	printf("%s Success match\r\n",temp2Expression);
	else
	printf("%s Fail match\r\n",temp2Expression);
	if(result1==1)
	printf("%s Success match\r\n",temp3Expression);
	else
	printf("%s Fail match\r\n",temp3Expression);
	return 0;
}

结果展示