数据结构：顺序栈与链栈

栈(Stack)

栈是先进后出(Last In Fast Out)的线性表，限定仅在表尾进行插入和删除操作的线性表，把允许插入删除的一端称为栈顶

栈示意图

进栈出栈变化形式

最先进栈的元素不一定最后出栈，因为栈对线性表的插入和删除的位置进行了限制，并没有对元素进出的时间进行限制，也就是说，在不是所有元素都进栈的情况下，事先进去的元素也可以出栈，只要保证是栈顶元素出栈就行

例如整型数字元素1，2，3依次进栈，出栈顺序可为：

• 第一种，1，2，3进，再3，2，1出，出栈次序321
• 第二种，1进，1出，2进，2出，3进，3出，出栈次序123
• 第三种，1进，2进，2出，1出，3进，3出，出栈次序213
• 第四种，1进，1出，2进，3进，3出，2出，出栈次序132
• 第五种，1进，2进，2出，3进，3出，1出，出栈次序231

3个元素会有5种出栈次序

栈的顺序存储结构

栈是线性表的特例，栈的顺序存储结构其实是线性表顺序存储的简化，称为顺序栈，顺序栈结构体如下：

typedef int ElemType;   /* ElemType类型根据实际情况而定，这里假设为int */  
typedef struct Stack
{
	Elemtype *elem;
	int top;   /* 用于栈顶指针 */
	int stacksize;  /* 栈的空间大小 */
}SqStack;

顺序栈的初始化

1. 开辟初始空间
2. 初始化top
3. 初始化stacksize

void InitStack(PStack st)
{
	assert(st != NULL);  //确保st不为空指针
			
	st->elem = (ElemType*)malloc(sizeof(ElemType)*STACK_INIT_SIZE);
	st->stacksize = STACK_INIT_SIZE;
	st->top = -1;
}

顺序栈的扩容

1. 开辟空间
2. 更新stacksize

static void AppendStack(PStack st)//扩容
{
	assert(st != NULL);
	
	st->elem = (ElemType*)realloc(st->elem, st->stacksize + sizeof(ElemType)*STACKINCREMENT);
	st->stacksize += STACKINCREMENT;
}

顺序栈的进栈(Push)

对于进栈操作push，其实做了三件事情

1. 判断栈满
2. 栈顶指针加一
3. 将新插入元素赋值给栈顶空间

void Push(PStack st, ElemType val)
{
	assert(st != NULL);
		
	if (st->top == st->stacksize)  //判断栈满
	{
		AppendStack(st);
	}
	st->top++;  //栈顶指针加一
	st->elem[st->top] = val;  //将新插入元素赋值给栈顶空间
	
}

顺序栈的出栈(Pop)

若栈不为空，则弹出栈顶元素给e，栈顶指针减一

int Pop(PStack st, ElemType *e)  // 若栈不为空，则弹出栈顶元素给e，栈顶指针减一
{
	assert(st != NULL);
		
	if (st->top >= 0)
	{
		*e = st->elem[st->top];
		st->top--;
		return 1;
	}
	return 0;	
}

顺序栈的销毁

void Destory(PStack st)
{
	assert(st != NULL);

	free(st->elem);
	st->elem = NULL;
	st->stacksize = 0;
}

顺序栈的清空

void Clear(PStack st)
{
	assert(st != NULL);
	
	st->top = 0;
}

顺序栈判空

bool IsEmpty(PStack st)
{
	assert(st != NULL);

	return st->top == -1;
}

获取顺序栈栈顶元素

ElemType GetTop(PStack st)
{
	assert(st != NULL);
	return st->elem[st->top];
}

栈的链式存储结构

栈的链式存储结构是用链表方式来实现栈，简称链栈，
链栈把栈顶放在单链表的头部，如下图所示：

链栈结构体如下：

typedef struct StackNode  // 栈结点
{
	ElemType data;
	struct StackNode *next;
}StackNode,*LinkStackPtr;

typedef struct LinkStack  // 链栈
{
	LinkStackPtr top;
	int count;
}LinkStack;

链栈的操作绝大部分都和单链表类似，只是在插入和删除上，特殊一些

链栈的进栈(Push)

假设要进栈的是元素值为e的新节点s，top为栈顶指针，则进栈示意图如下：

1. 将当前的栈顶元素赋值给新节点的直接后继
2. 更新栈顶指针，使其指向新元素

Status Push(LinkStack *LS, ElemType e)
{
	LinkStackPtr s = (LinkStackPtr)malloc(sizeof(StacNode));
	s->data = e;
	
	s->next = LS->top; //将当前的栈顶元素赋值给新节点的直接后继
	LS->top = s;  //更新栈顶指针，使其指向新元素
	
	LS->count++;
	
	return OK;
}

链栈的出栈(Pop)

假设变量p用来存储要删除的栈顶结点

1. 将栈顶结点赋值给p，如下图步骤1
2. 栈顶指针下移一位，如下图步骤2
3. 释放结点p

//若栈不为空，则删除栈顶元素，用e返回其值，并返回OK；否则返回ERROR
Status Pop(LinkStack *S, ElemType *e)
{
	LinkStackPtr p;
	if(StackEmpty(*S))
	{
		return ERROR;
	}
	*e = S->top->next;
	
	p = S->top; //将栈顶结点赋值给p，如上图步骤1
	S->top = S->top->next;  //栈顶指针下移一位，如上图步骤2
	free(p);  //释放结点p
	S->count--;
	
	return OK;
}

顺序栈与链栈对比

顺序栈与链栈的进栈出栈时间复杂度均为O(1)。对于空间性能，顺序栈需要事先确定一个固定的长度，可能会存在内存空间浪费的问题，但它的优势是存取定位很方便，而链栈则要求每个元素都有指针域，这同时也增加了一些内存开销，但对于栈的长度可以灵活开辟。所以他们的区别如同顺序表与链表的区别。
如果栈的使用过程中元素的变化不可预料，有时很小，有时很大，那么最好用链栈；反之，如果它的变化在可控范围内，则可使用顺序栈