栈数据结构详解与实现-优快云博客

</pre><pre name="code" class="cpp">在数据结构中，栈是限制在表的一端进行插入和删除的线性表。在线性表中允许插入、删除的这一端称为栈顶，栈顶的当前位置是动态变化的，这样我们只能在栈顶对栈进行操作；不允许插入和删除的另一端称为栈底，栈底是固定不变得，当表中没有元素时称为空栈。
 对栈的常用操作有：
栈初始化：Init_Stack()  初始条件：栈不存在  操作结果：构造了一个空栈
判断空： Empty_Stack()  若栈空，则返回为1，否则返回0
入栈：   Push_Stack(S,x)    初始条件：栈S已经存在  操作结果：在栈S的顶部插入一个元素x，这样x就、成为新的栈顶元素。
出栈：   Pop_Stack(S,&x)   初始条件：栈S存在且不为空  操作结果：栈S的顶部元素从栈顶删除，保存在变量x中
取栈顶元素： GetTop_Stack(S)  初始条件：栈s存在且不为空  操作结果：返回栈S的栈顶元素，且原栈的结构不会变化
销毁栈：     Destory_Stack(S) 初始条件：栈S已经存在  操作结果： 销毁一个已经存在的栈
栈的存储方式：（1）顺序存储 （2）链式存储
下面我分别介绍这两种的实现：
顺序存储
    顺序存储中用int data[STACKSIZE] 来存放所有的入栈元素，栈底的位置可以设置固定在数组的任意一端，栈顶指示实际的栈顶元素位置，它是随着插入和删除是动态变化的，用int top变量来指示栈顶的位置
 将data 和 top封装在一个结构中
#define MAXSIZE 100
typedef{
    DataType data[STACKSIZE];
     int top;
}SeqStack,*PSeqStack；
下面用一个实例介绍栈的一些基本操作(经过测试)：
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define STACKSIZE 100
typedef struct{
 int data[STACKSIZE];
 int top;
}SeqStack,*PSeqStack;
PSeqStack Init_SeqStack()
{
 PSeqStack S;
 S=(PSeqStack)malloc(sizeof(SeqStack));
 if(S!=NULL)
  S->top=-1;
 return S;
}

int Empty_SeqStack(PSeqStack S)
{
 if(S->top==-1)
  return 1;
 else return 0;
}

int Push_SeqStack(PSeqStack S,int x)
{
 if(S->top==STACKSIZE-1)
  return 0;
 else{
  S->top++;
  S->data[S->top]=x;
  return 1;
 }
}

int Pop_SeqStack(PSeqStack S,int *x)
{
 if(Empty_SeqStack(S)==1)
  return 0;
 else{
  *x=S->data[S->top];
  S->top--;
  return 1;
 }
}
int GetTop_SeqStack(PSeqStack S)
{
 if(Empty_SeqStack(S)==1){
  printf("Empty Stack!\n");
  return -1;
 }
 else
  return S->data[S->top];
}
int Destory_SeqStack(PSeqStack *S)
{
 if(*S){
  free(*S);
  *S=NULL;
  return 1;
 }
 return 0;
}
int main()
{
 PSeqStack s;
 int x=0;
 s=Init_SeqStack();
 Push_SeqStack(s,1);
 Push_SeqStack(s,2);
 Push_SeqStack(s,3);
 Push_SeqStack(s,4);
 printf("Top:%d ",GetTop_SeqStack(s));
 Destory_SeqStack(&s);
 return 1;
}
链式存储
   栈的链式存储一般用单链表来实现，实现代码如下：
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define STACKSIZE 100
typedef struct LinkStack{
 int data;
 struct LinkStack *next;
}LinkStackNode,*PLinkStackNode;
typedef struct{
 PLinkStackNode top;
}LinkStack,*PLinkStack;
PLinkStack Init_LinkStack()
{
 PLinkStack s;
 s=(PLinkStack)malloc(sizeof(LinkStack));
 if(s)
  s->top=NULL;
 return s;
}

int Empty_LinkStack(PLinkStack S)
{
 if(S->top==NULL)
  return 1;
 else return 0;
}

int Push_LinkStack(PLinkStack S,int x)
{
 PLinkStackNode p;
 p=(PLinkStackNode)malloc(sizeof(LinkStackNode));
 if(p!=NULL){
  p->data=x;
  p->next=S->top;
  S->top=p;
  return 1;
 }else
  return 0;
}

int Pop_LinkStack(PLinkStack S,int *x)
{
 PLinkStack p;
 if(Empty_LinkStack(S)==1)
  return 0;
 else{
  p=S;
  *x=S->top->data;
  S->top=S->top->next;
  free(p);
  return 1;
 }
}
int GetTop_LinkStack(PLinkStack S)
{
 if(Empty_LinkStack(S)==1){
  printf("Empty Stack!\n");
  return -1;
 }
 else
  return S->top->data;
}
int Destory_LinkStack(PLinkStack *S)
{
 PLinkStackNode p,q;
 if(*S){
  p=(*S)->top;
  while(p){
   q=p;
  p=p->next;
  free(q);
  }
  free(*S);
 }
 *S=NULL;
 return 1;
}
int main()
{
 PLinkStack s;
 int x=0;
 s=Init_LinkStack();
 Push_LinkStack(s,1);
 Push_LinkStack(s,2);
 Push_LinkStack(s,3);
 Push_LinkStack(s,6);
 printf("Top:%d ",GetTop_LinkStack(s));
 Destory_LinkStack(&s);
 return 1;
}

#include "stdafx.h"
#include<cstdio>
#include<cstdlib>
#define OK 1
#define TRUE 1
#define ERROR 0
#define FALSE 0
#define overflow -2
#define STACK_INTT_SIZE 100
#define STACK_INIT_INCREMENT 20
#define Status int
#define ElemType int
typedef struct
{
ElemType *base,*top;
int stackSize;
}SqStack;
/* 栈的操作
Status InitStatck(SqStack &s) 初始化栈
Status DestoryStatck(SqStack &s) 销毁栈
Status ClearStack(SqStack &s) 清除栈
bool StackEmpty(SqStack s) 栈是否为空
int StackLength(SqStack s) 栈的长度
Status GetTop(SqStack s,SElemType &e) 得到栈顶
Status Push(SqStack &s,SElemType e) 压栈
Status Pop(SqStack &s,SElemType &e) 出栈
void DisplayStack(SqStack s); 显示栈内的元素
*/
Status InitStatck(SqStack &s)
{
s.base=(ElemType*)malloc(STACK_INTT_SIZE*(sizeof(ElemType)));
if(!s.base)
return ERROR;
else
s.top=s.base;
s.stackSize=STACK_INTT_SIZE;
}
Status DestoryStatck(SqStack &s)
{
s.top=s.base;
free(s.base);
s.base=NULL;
s.top=NULL;
return OK;
}
bool StackEmpty(SqStack s)
{
if(s.base==s.top)
return TRUE;
else
return FALSE;
}
int StackLength(SqStack s)
{
if(s.base=s.top)
return ERROR;
else
return (s.top-s.base);
}
Status GetTop(SqStack s,ElemType &e)
{
if(StackEmpty(s))
{
printf("This stack is empty.");
return ERROR;
}
else
{
s.top--;
e=*s.top;
return OK;
}
}
Status Push(SqStack &s,ElemType e)
{
if(StackLength(s)==STACK_INTT_SIZE)
{
ElemType*temp=(ElemType*)realloc(s.base,(STACK_INTT_SIZE+STACK_INIT_INCREMENT)*(sizeof(ElemType)));
if(!temp)
return ERROR;
s.base=temp;
s.top=s.base+STACK_INTT_SIZE;
s.stackSize=STACK_INTT_SIZE+STACK_INIT_INCREMENT;
*(s.top++)=e;
return OK;
}
else
{
*s.top=e;
s.top++;
return OK;
}
}
Status Pop(SqStack &s,ElemType &e)
{
if(StackEmpty(s))
{
printf("This stack is empty.");
return ERROR;
}
else
{
e=*(--s.top);
return OK;
}
}
Status ClearStack(SqStack &s)
{
s.top=s.base;
s.stackSize=0;
return OK;
}
void DisplayStack(SqStack s)
{
if(StackEmpty(s))
exit(-1);
while(s.top!=s.base)
printf("%d\n",*(--s.top));
}
int _tmain(int argc, _TCHAR* argv[])
{
SqStack statck;
InitStatck(statck);
for(int i=0;i<5;i++)
{
if(Push(statck,i))
printf("%d is push in this statck success!\n",i);
else
printf("/n/thappen a error\n\t");
}
DisplayStack(statck);//显示栈内的元素
int tem;
printf("now i will print this top of statck !\n");
GetTop(statck,tem);
printf("%d is top of this statck\n",tem);

DestoryStatck(statck);

system("pause");
return 0;
}