栈操作（C语言）

通过C语言实现栈的建立、入栈、弹栈、返回栈顶元素、判断栈是否为空、销毁栈、清空栈、计算栈的当前容量等操作。写了4种方式，前面两种是数组，后面两种是链表。
1、

#include<stdio.h>
#include<stdlib.h>

#define MAXSIZE 1024    //初始化栈有1024个空间 


typedef int ElemType;


typedef struct
{
	ElemType *top;   //指向栈顶的指针变量 
	ElemType *base;  //指向栈底 的指针变量 
	int stackSize;   //栈可使用的最大容量 
}SeqStack;

//创建栈
void InitStack(SeqStack *s)
{
	s->base=(ElemType*)malloc(MAXSIZE*sizeof(ElemType));
	if(!s->base)
		exit(0);
	s->top=s->base;
	s->stackSize=MAXSIZE;
} 
 

//判断栈是否为空
int Isempty(SeqStack *s)
{
	if(s->base==s->top)
		return 0;
	return 1;
} 


//返回栈顶元素
int SeqStack_Top(SeqStack *s)
{
	if(Isempty(s))
	{
		
		int e=*--(s->top);
		s->top++;
		return e;
	}
		
	printf("栈为空返回失败\n");
	return -1;
}

//出栈 
int  SeqStack_Pop(SeqStack *s)
{
	if(Isempty(s))
	{
		return *--(s->top);
	}
	printf("栈为空返回失败\n");
	return -1;
}

//入栈
void Stack_Push(SeqStack *s,ElemType vue)
{
	if(s->top-s->base>=MAXSIZE)
	{
		s->base=(ElemType*)realloc(s->base,2*MAXSIZE*sizeof(ElemType));
		s->top=s->base+s->stackSize;
		s->stackSize=MAXSIZE*2;
		
	}
	*(s->top)=vue;	
	s->top++;
} 

//销毁栈
void Stack_Cleer(SeqStack *s)
{
	for(int i=0;i<s->stackSize;i++)
	{
		free(s->top--);
	}
	s->base=s->top=NULL;
	s->stackSize=0;
} 

//计算栈的当前容量 即栈中元素个数
int Stack_Len(SeqStack *s)
{
	return (s->top-s->base);
} 

//清空栈
void Stack_Clear(SeqStack *s) 
{
	s->top=s->base;
}

//输出栈中的元素
void Stack_Print(SeqStack *s,int m)//m表示输出元素的个数 
{
	for(int i=0;i<m;i++)
	{
		printf("%d ",SeqStack_Pop(s));	
	} 
 } 

int main()
{
	SeqStack s;
	int m;
	InitStack(&s);
	for(int i=1;i<=10;i++)
	{
		Stack_Push(&s,i);
	}
	printf("栈顶元素为：%d\n",SeqStack_Top(&s));
	printf("栈的当前容量为：%d\n",Stack_Len(&s));
	printf("请输入要输出元素的个数：");
	scanf("%d",&m);
	Stack_Print(&s,m);
	return 0;
}

2、

#include<stdio.h>
#include<stdlib.h>

#define MAXSIZE 1024


typedef int ElemType;


typedef struct
{
	 ElemType top;
	 int data[MAXSIZE];
}SeqStack;

//初始化栈
void InitStack(SeqStack *stack)
{
	stack->top=-1;
 } 
 
//判断栈是否为空
int Isempty(SeqStack *stack)
{
	if(stack->top==-1)
		return 0;
	return 1;
} 

//返回栈顶元素
int SeqStack_Top(SeqStack *stack)
{
	if(Isempty(stack))
		return stack->data[stack->top];
	return 0;
}

//弹出栈顶元素
int  SeqStack_Pop(SeqStack *stack)
{
	if(Isempty(stack))
		return stack->data[stack->top--];
	return 0;
}

//入栈
void Stack_Push(SeqStack *stack,ElemType vue)
{
	if(stack->top>=MAXSIZE-1)        //栈满 
		return;
	stack->top++;
	stack->data[stack->top]=vue;
	
 } 

//销毁栈
void Stack_Cleer(SeqStack *stack)
{
	if(Isempty(stack))
		free(stack);
 } 

//输出栈中的元素
void Stack_Print(SeqStack *stack,int m)//m表示输出元素的个数 
{
	for(int i=0;i<m;i++)
	{
		printf("%d ",SeqStack_Pop(stack));
	}
 } 

int main()
{
	SeqStack stack;
	int m;
	InitStack(&stack);
	for(int i=1;i<=10;i++)
	{
		Stack_Push(&stack,i);
	}
	printf("栈顶元素:%d\n",SeqStack_Top(&stack));
	printf("请输入要输出元素的个数：");
	scanf("%d",&m);
	Stack_Print(&stack,m);
	return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<math.h>

typedef int ElemType;
 
typedef struct StackNode
{
	ElemType data;		//存放栈的数据 
	struct StackNode *next;
}StackNode,*LinkStackPtr;

typedef struct LinkStack
{
	LinkStackPtr top;	//top指针 
	int count;			//栈元素计数器 
}LinkStack; 

//初始化
void InitLinkStack(LinkStack *s)
{
	s->top=NULL;
	s->count=0;
} 

//入栈
void Push(LinkStack *s,ElemType e)
{
	LinkStackPtr p=(LinkStackPtr)malloc(sizeof(StackNode));
	p->data=e;
	p->next=s->top;
	s->top=p;
	s->count++;
	
}


//判断栈是否为空
int StackEmpty(LinkStack s)
{
	if(s.top==NULL)
	{
		printf("空栈");
		return 0;
	}
	return 1;
 } 


//出栈
ElemType Pop(LinkStack *s,ElemType *e)
{
	LinkStackPtr p;
	if(StackEmpty(*s))
	{
		*e=s->top->data;
		p=s->top;
		s->top=s->top->next;
		free(p);
		s->count--;
		return *e;
	}
	
}

//输出所有元素
void Print(LinkStack s)
{
	ElemType e;
	while(p.top&&s.count)
	{
		printf("%d ",Pop(&s,&e));
	}
	
 } 
int main()
{
	LinkStack s;
	InitLinkStack(&s);
	for(int i=0;i<10;i++)
	{
		Push(&s,i);
	}
	Print(s);
	return 0;
}

4、

#include<stdio.h>
#include<stdlib.h>


typedef int ElemType;
 
typedef struct StackNode
{
	ElemType data;		//存放栈的数据 
	struct StackNode *next;
}StackNode,*LinkStackPtr;

//初始化 
void InitStack(LinkStackPtr *s)
{
	if(s==NULL)
		return;
	*s=NULL;
}

//入栈
void Push(LinkStackPtr *s,ElemType e)
{
	if(s==NULL)
		return;
	LinkStackPtr p=(LinkStackPtr)malloc(sizeof(StackNode));
	if(!p)
	{
		printf("内存分配失败\n");
		exit(0);
	}
	p->data=e;
	p->next=*s;
	*s=p;
} 
 
//弹栈
void Pop(LinkStackPtr *s,ElemType *e)
{
	if(s==NULL)
		return;
	
	if(*s==NULL)
	{
		return;
	}
	LinkStackPtr p=*s;
	*e=p->data;
	*s=p->next;
	free(p);
 } 
int main()
{
	LinkStackPtr s;
	int e;
	InitStack(&s);
	for(int i=0;i<10;i++)
	{
		Push(&s,i);	
	}
	Pop(&s,&e);
	printf("%d",e);
	for(int i=0;i<5;i++)
	{
		Pop(&s,&e);
		printf("%d",e);
	}
	return 0;
}