数据结构之栈（后进先出表）

栈(Stack)是一种特殊的线性表，其插入和删除操作均在表的一端进行，是一种运算受限的线性表
栈顶(top)是栈中允许插入和删除的一端。
栈底(bottom)是栈顶的另一端
顺序栈：

#include<stdio.h>
#include<stdlib.h>
#define Stack_Init_Size 100 //栈容量
#define StackIncrement 10 //栈增量
#define OVERFLOW -1
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status;
typedef int SElemType;
typedef int Status;
typedef struct {
	SElemType *base;
	SElemType *top;
	int stacksize;
}SqStack;
Status InitSqStack(SqStack* S)
{
	S->base = (SElemType*)malloc(Stack_Init_Size * sizeof(SElemType));
	S->top = S->base;
	S->stacksize = Stack_Init_Size;
	return OK;
}
Status Push(SqStack* s, SElemType e)
{
	if (s->top - s->base >= s->stacksize)
	{
		s->base = (SElemType*)realloc(s->base,((int)s->stacksize + StackIncrement) * sizeof(SElemType));
		if (s->base==NULL)
			exit(OVERFLOW);
		s->top = s->base + s->stacksize;
		s->stacksize += StackIncrement;
	}
	*(s->top) = e;
	s->top++;
	return OK;
}
SElemType Pop(SqStack* s)
{
	SElemType e;
	if (s->top == s->base)
	{
		return ERROR;
	}
	else
	{
		s->top--;//注意出栈是先--
		e = *(s->top);
		return e;
	}
}
Status Destroy(SqStack* S)
{
	free(S->base);
	S->base = NULL;
	S->top = NULL;
	S->stacksize = 0;
	return OK;
}
Status Clear(SqStack* S)
{
	S->top = S->base;
	return OK;
}
Status Is_empty(SqStack* S)
{
	if (S->top == S->base)
		return TRUE;
	else
		return FALSE;
}
int Length(SqStack* S)
{
	return (int)(S->top - S->base);
}
void StackTraverse(SqStack* s)
{
	SElemType* p;
	p = s->top;
	while (p!=s->base)
	{ 
		p--;
		printf("%d\n", *(p));
	}
}
SElemType GetTop(SqStack* s)
{
	s->top--;
	return *s->top;
}
int main()
{
	SqStack* s=(SqStack*)malloc(sizeof(SqStack));
	InitSqStack(s);
	for (int i = 0; i < 10; ++i)
	{
		Push(s, i);
	}
	printf("长度： %d\n", Length(s));
	for (int i = 0; i < 10; ++i)
	{
		printf("%d\n", Pop(s));
	}
	return 0;
}

链式栈

#include<stdio.h>
#include<stdlib.h>
#define Stack_Init_Size 100 //栈容量
#define StackIncrement 10 //栈增量
#define OVERFLOW -1
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status;
typedef int SElemType;
typedef int Status;
typedef struct SNode {
	SElemType data;
	struct  SNode* next;
}SNode,*LinkStack;
LinkStack InitStack()//注意这个初始化方式！！！！！！
{
	LinkStack s = (SNode*)malloc(sizeof(SNode));
	if (!s)
		exit(OVERFLOW);
	s->next = NULL;
	return s;
}
void Push(LinkStack s, SElemType e)
{
	LinkStack p = (SNode*)malloc(sizeof(SNode));
	if (p == NULL)
		exit(OVERFLOW);
	p->data = e;
	p->next = NULL;
	p->next = s->next;
	s->next=p;//与单链表的头插法相似
}
SElemType Pop(LinkStack s)
{
	LinkStack q;
	q = s->next;
	SElemType e= q->data;
	s->next = q->next;  
	free(q);//删除单链表的第一个元素
	return e;
}
void DestroyStack(LinkStack s)
{
	free(s);
}
void ClearStack(LinkStack s)
{
	s->next = NULL;
}
Status StackEmpty(LinkStack s)
{
	if (s->next == NULL)
		return TRUE;
	else
	{
		return FALSE;
	}
}
int StackLength(LinkStack s)
{
	int i = 0;
	SNode* p = s->next;
	while (p!=NULL)
	{
		i++;	
		p = p->next;
	}
	return i;
}
SElemType GetTop(LinkStack l)
{
	return l->next->data;
}
void StackTravers(LinkStack s)
{
	SNode* p = s->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
}
int main()
{
	LinkStack s = (SNode*)malloc(sizeof(SNode));
	s=InitStack();
	for (int i = 0; i < 10; i++)
	{
		Push(s, i);
	}
	Pop(s);
	StackTravers(s);
	return 0;
}