线性结构-栈的顺序存储和链式存储实现

栈的顺序存储表示

栈的顺序存储结构简称为顺序栈，和线性表相类似，用一维数组来存储栈。根据数组是否可以根据需要增大，又可分为静态顺序栈和动态顺序栈。静态顺序栈实现简单，但不能根据需要增大栈的存储空间；动态顺序栈可以根据需要增大栈的存储空间，但实现稍为复杂。

栈的动态顺序存储表示

采用动态一维数组来存储栈。所谓动态，指的是栈的大小可以根据需要增加。

用bottom表示栈底指针，栈底固定不变的；栈顶则随着进栈和退栈操作而变化。用top(称为栈顶指针)指示当前栈顶位置。

用top=bottom作为栈空的标记，每次top指向栈顶数组中的下一个存储位置。

结点进栈：首先将数据元素保存到栈顶(top所指的当前位置)，然后执行top加1，使top指向栈顶的下一个存储位置;

结点出栈：首先执行top减1，使top指向栈顶元素的存储位置，然后将栈顶元素取出。

栈的静态顺序存储表示

采用静态一维数组来存储栈。

栈底固定不变的；栈顶则随着进栈和退栈操作而变化，用一个整型变量top(称为栈顶指针)来指示当前栈顶位置。

用top=0表示栈空的初始状态，每次top指向栈顶在数组中的存储位置。

结点进栈：首先执行top加1，使top指向新的栈顶位置，然后将数据元素保存到栈顶(top所指的当前位置)。

结点出栈：首先把top指向的栈顶元素取出，然后执行top减1，使top指向新的栈顶位置。

若栈的数组有Maxsize个元素，则top=Maxsize-1时栈满。

/*!
* \file 栈的顺序存储实现.cpp
*
* \author ranjiewen
* \date 2017/03/17 11:13
*
*
*/

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

typedef int Position;
typedef int ElemType;
#define  ERROR NULL
#define  MAXSIVE 100

struct SNode
{
ElemType *Data; /*存储元素的数组，动态分配内存*/
Position Top; /*栈顶元素数组下标*/
int MaxSize; // 堆栈最大容量
};

typedef struct SNode* Stack;

Stack CreateStack(int MaxSize)
{
Stack S = (Stack)malloc(sizeof(struct SNode));
S->Data = (ElemType*)malloc(MaxSize*sizeof(ElemType));
S->Top = -1; //顺序存储结构时，表示空
S->MaxSize = MaxSize;
return S;
}

bool IsFull(Stack S)
{
return (S->Top == S->MaxSize - 1);
}

bool Push(Stack S, ElemType x)
{
if (IsFull(S))
{
printf("堆栈满.\n");  //栈满时可以再申请空间
return false;
}
else
{
S->Data[++(S->Top)] = x;
return true;
}
}

bool IsEmpty(Stack S)
{
return (S->Top == -1);
}

ElemType Pop(Stack S)
{
if (IsEmpty(S))
{
printf("堆栈为空。\n");
return ERROR;
}
else
{
return S->Data[(S->Top)--];
}
}

int main()
{
struct SNode *S = CreateStack(MAXSIVE);
for (int i = 9; i >= 0;i--)
{
Push(S,i);
}
for (int i = 0; i < S->Top;i++)
{
printf("%d ", S->Data[i]);
}
printf("\n");
Pop(S);
Pop(S);
for (int i = 0; i < S->Top; i++)
{
printf("%d ", S->Data[i]);
}
printf("\n");
return 0;
}

存储栈的链式表示

栈的链式存储结构称为链栈,是运算受限的单链表。其插入和删除操作只能在表头位置上进行。因此,链栈没有必要像单链表那样附加头结点,栈顶指针top就是链表的头指针。记住栈顶指针Top只能在表尾，在表头时删除操作不行。

/*!
* \file 线性结构栈的链式存储实现.cpp
*
* \author ranjiewen
* \date 2017/03/17 14:27
*
*
*/

#include<stdio.h>
#include <stdlib.h>
typedef int ElementType;
#define  ERROR NULL

typedef struct SNode *PtrToSNode;
struct SNode {
ElementType Data;
PtrToSNode Next;
};
typedef PtrToSNode Stack;

Stack CreateStack()
{ /* 构建一个堆栈的头结点，返回该结点指针 */
Stack S;
S = (Stack)malloc(sizeof(struct SNode));
S->Next = NULL;
return S;
}

bool IsEmpty(Stack S)
{ /* 判断堆栈S是否为空，若是返回true；否则返回false */
return (S->Next == NULL);
}

bool Push(Stack S, ElementType X)
{ /* 将元素X压入堆栈S */
PtrToSNode TmpCell;

TmpCell = (PtrToSNode)malloc(sizeof(struct SNode));
if (!TmpCell)
{
printf("申请结点失败!");
exit(-1);
}
TmpCell->Data = X;        //相当于在表头插入
TmpCell->Next = S->Next;
S->Next = TmpCell;
return true;
}

ElementType Pop(Stack S)
{ /* 删除并返回堆栈S的栈顶元素 */
PtrToSNode FirstCell;
ElementType TopElem;

if (IsEmpty(S)) {
printf("堆栈空");
return ERROR;
}
else {
FirstCell = S->Next;
TopElem = FirstCell->Data;
S->Next = FirstCell->Next;
free(FirstCell);
return TopElem;
}
}

int main()
{
PtrToSNode stack;
stack = CreateStack();
for (int i = 9; i >= 0;i--)
{
Push(stack, i);
}
PtrToSNode pTemp;
for (pTemp = stack->Next; pTemp != NULL;pTemp=pTemp->Next) //链式不能用++
{
printf("%d ", pTemp->Data);
}
printf("\n");
Pop(stack);
Pop(stack);
for (pTemp = stack->Next; pTemp != NULL; pTemp=pTemp->Next)
{
printf("%d ", pTemp->Data);
}
printf("\n");
}

reference：[数据结构]线性结构——栈