顺序栈是用数组实现的：（假设我们有8个位置（下标0-7））

#include<stdio.h>
#include<malloc.h>
#include<assert.h>
#include <iostream>
#define MAX_SIZE 8

#define Elemtype int 
typedef struct stack{
	Elemtype *base;
	int top;
	int stacksize;
}Sqstack;

void Initstack(Sqstack *S)
{
	S->base=(Elemtype*)malloc(sizeof(Elemtype)*MAX_SIZE);
	S->stacksize=8;
	S->top=0; 
 }

入栈：

假设我们将20入栈

我们只需要在Top的位置插入，然后Top加1，而Top每次总是指向下一次插入的位置。

栈如果满了，Top应该是等于8的。

 void push(Sqstack *S,Elemtype x)
 {
	if(s->top==MAX_SIZE)
	{
		printf("满了,%d不能入栈\n",x);
		return;
	}
	S->base[S->top++]=x;
 }

出栈

空栈top=0：

出栈直接让Top--就行，因为下一次入栈这个位置就能被抵消掉。

 void pop(Sqstack *S)
 {
 	if(s->top==0)
 	{
 		printf("空的");
 		return;
	 }
	 S->top--;
 }

栈的应用：

二进制转换

 bool IsEmpty(Sqstack *S)
 {
 	return S->top==0;
 }

Elemtype Gettop(Sqstack *S) 
 {
 	if(IsEmpty(S))
 	{
 		return false;
	 }
	 return S->base[S->top-1];
 }


void conversion(int value)
{	Sqstack s;
	Initstack(&s);
	
	while(value)
	{
		push(&s,value%8);
		value=value/8;
	}
	while(!IsEmpty(&s))
{	int v;
	v=Gettop(&s);
	pop(&s);
	printf("%d",v);
	}	
}

括号匹配（只需将元素类型变为char就行）：

bool Cheack(char *str)
{ char v;
	Sqstack s;
	Initstack(&s);
	while(*str !='0')
	{
		if(*str=='['||*str=='(')
		{
			push(&s,*str);
		}
		else if(*str==']')
	{
		 v=Gettop(&s);
		if(v!='[')
			return false;
			pop(&s);
	}
	else if(*str==')')
	{
		 v=Gettop(&s);
		if(v!='(')
			return false;
			pop(&s);
	}
	++str;
	}
	return IsEmpty(&s);
}

顺序栈的所有代码（包含栈扩容等各种方法的实现）：

#define STACK_INC_SIZE 3
#include<stdio.h>
#include<malloc.h>
#include<assert.h>
#include <iostream>
#define MAX_SIZE 8

#define Elemtype char 
typedef struct stack{
	Elemtype *base;
	int top;
	int stacksize;
}Sqstack;

void Initstack(Sqstack *S)//初始化 
{
	S->base=(Elemtype*)malloc(sizeof(Elemtype)*MAX_SIZE);
	S->stacksize=8;
	S->top=0; 
 } 
 void show(Sqstack *S)//查看栈内元素 
 {
 	for(int i=S->top-1;i>=0;i--)
 	{
 		printf("%d\n",S->base[i]);
	}
 }
 bool IsFull(Sqstack *S)//判断是否满 
 {
 	return S->top>=S->stacksize; 
  } 
 bool IsEmpty(Sqstack *S)//判断是否为空栈 
 {
 	return S->top==0;
 }
 bool Inc(Sqstack *s)//栈满了则扩容，如果内存不够扩容则失败 
 {
 	Elemtype *newbase=(Elemtype*)realloc(s->base,sizeof(Elemtype)*(s->stacksize+STACK_INC_SIZE));
 	if(newbase==NULL)
 	{
 		printf("满了");
		 return false; 
	 }
	 s->base=newbase;
	 s->stacksize+=STACK_INC_SIZE;
	 return true;
 }
 
 void push(Sqstack *S,Elemtype x)//入栈 
 {
	if(IsFull(S)&&!Inc(S))
	{
		printf("满了,%d不能入栈\n",x);
		return;
	}
	S->base[S->top++]=x;
 }
 void pop(Sqstack *S)//出栈 
 {
 	if(IsEmpty(S))
 	{
 		printf("空的");
 		return;
	 }
	 S->top--;
 }
Elemtype Gettop(Sqstack *S) //获取栈顶元素 
 {
 	if(IsEmpty(S))
 	{
 		return false;
	 }
	 return S->base[S->top-1];
 }
 int length(Sqstack *S)//长度 
 {
 	return S->top;
 }
 void clear(Sqstack *S)//清空栈 
 {
 	S->top=0;
 }
 void destory(Sqstack *S)//销毁栈 
 {
 	free(S->base);
 	S->base=NULL;
 	S->stacksize=S->top==0;
 }
 
void conversion(int value)//进制转换 
{	Sqstack s;
	Initstack(&s);
	
	while(value)
	{
		push(&s,value%8);
		value=value/8;
	}
	while(!IsEmpty(&s))
{	int v;
	v=Gettop(&s);
	pop(&s);
	printf("%d",v);
	}	
}

bool Cheack(char *str)//括号匹配 
{ char v;
	Sqstack s;
	Initstack(&s);
	while(*str !='0')
	{
		if(*str=='['||*str=='(')
		{
			push(&s,*str);
		}
		else if(*str==']')
	{
		 v=Gettop(&s);
		if(v!='[')
			return false;
			pop(&s);
	}
	else if(*str==')')
	{
		 v=Gettop(&s);
		if(v!='(')
			return false;
			pop(&s);
	}
	++str;
	}
	return IsEmpty(&s);
}
int main(void)
{
	char *str="[())]";
	bool flag=Cheack(str);
	if(flag)
	{
		printf("OK\n");
	}
	else{
		printf("False");
	}
	
	
 }