堆栈

堆栈

定义：
堆栈简称栈
堆栈是一种只允许在表的一端进行插入操作和删除操作的线性表。允许操作的一端称为栈顶，栈顶元素的位置由一个称为栈顶指针的变量给出。当表中没有元素时，称之为空栈。
由于堆栈只允许在一端操作，后进入的数据往往会先处理，简称为后进先出，如下图：

堆栈的基本操作
1、插入（进栈、入栈）
2、删除（出栈、退栈）
3、测试堆栈是否为空
4、测试堆栈是否已满
5、检索当前栈顶元素
其操作收到位置的限制，所以只是一般线性表操作的一个子集。

堆栈的顺序存储结构和操作
1、构造原理
描述堆栈的顺序存储结构最简单的方法是利用一维数组STACK[ 0: M–1 ]来表示，同时定义一个整型变量(不妨取名为top)给出栈顶元素的位置，如下图

top等于堆栈顶部的下标

堆栈的溢出：

上溢：当堆栈已经满时做插入操作（top=M-1）
下溢：当堆栈为空时做删除操作（top=-1）

堆栈类型定义如下：

1. #define M 1000
2. SElemType STACK[M];
3. int top;             //初始时 top=-1 

2、初始化堆栈

1. void INITIALS( int  &top )
2. {
3.     top= –1;
4. }

3、测试堆栈是否为空

1. int EMPTYS( int top )
2. {    
3.     return top == –1;    //栈空返回 1 ，否则返回 0
4. }

4、测试堆栈是否已满

1. int FULLS( int top )
2. {
3.     return top==M–1;     //栈满返回 1 ，否则返回 0
4. }

5、插入（进栈）算法

1. int PUSH( SElemType STACK[ ], int  &top, SElmeType item )
2. {
3.     if( FULLS(top) )
4.         return 0;
5.     else
6.    {
7.         STACK[++top]=item；
8.         return 1;
9.     }
10. }

6、删除（出栈）算法

1. int POP( SElemType STACK[ ], int  &top, SElemType  &item )
2. {
3.     if( EMPTYS(top) )
4.         return 0;
5.     else
6.    {
7.         item=STACK[top--];      //先取出top，再top减1
8.         return 1;
9.     }
10. }

多栈共享连续空间问题
在堆栈的顺序存储方式中，有时为了减少空间碎片，提高空间利用率，会设置多个堆栈共享一个连续空间，以下以两个堆栈共享一个数组为例，如下：

入栈的C语言实现（一）如下：

1. int PUSH( SElemType STACK[ ], int top[ ], int i, SelemType item )
2. {
3.         if(top[0]==top[1]–1)           /* 栈满 */
4.              return 0;
5.         else{
6.                  if(i==1)                    /* 插入第1个栈 */
7.                        STACK[++top[0]]=item;
8.                  else                        /* 插入第2个栈 */
9.                       STACK[– –top[1]]=item;
10.                  return 1;
11.        }
12. }

入栈的C语言实现（二）如下：

1. int PUSH( SElemType STACK[ ], int top[ ], int i, SElemType item )
2. {
3.             if (top[0]==top[1]–1)
4.                   return 0;
5.             else {
6.                    if (i==1)
7.                         top[0]++;             /* 修改第1个栈顶指针 */
8.                    else
9.                         top[1]– –;            /* 修改第2个栈顶指针 */
10.                   STACK[top[i–1]]=item;
11.                   return 1;
12.           }
13. }

一和二本质一样，只不过二的写法更简洁；

出栈的C语言实现如下：

1. int POP( SElemType STACK[ ], int top[ ], int i, SElemType item )
2. {
3.         if(i==1)                                       //对第一个栈进行操作
4.                if(top[0]==–1)
5.                    return 0;
6.                else
7.               {
8.                   item=STACK[top[0]– –];
9.                   return 1;
10.                }
11.        else
12.                if(top[1]==M)
13.                    return 0;
14.                else{
15.                     item=STACK[top[1]++];
16.                     return 1;
17.               }
18. }

堆栈的链式存储结构
1、构造原理
链接堆栈就是用一个线性链表来实现一个堆栈结构, 同时设置一个指针变量( 这里不妨仍用top表示)指出当前栈顶元素所在链结点的位置。栈为空时，有top=NULL。如下图

C语言实现如下：

1. typedef struct node
2. { 
3.     SElmeType data;
4.     struct node *link;
5. } STNode, *STLink;

2、堆栈初始化

1. void INITIAL( STLink &top )
2. {
3.     top = NULL;
4. }

3、测试堆栈是否为空

1. int EMPTYS( STLink  top )
2. {
3.     return top==NULL;
4. }

4、插入（进栈）算法 （不必判断栈满）

1. int PUSHLINK( STLink  &top, SElemType item )
2. { 
3.     STLink p;
4.     if( !(p=(STLink)malloc(sizeof(STNode)) )          //申请一个新的链节点
5.         return 0; 
6.     else
7.     {
8.         p->data=item;      /*将item送新结点数据域*/
9.         p->link=top;         /*将新结点插在链表最前面*/
10.         top=p;                 /*修改栈顶指针的指向*/
11.         return 1;
12.     }
13. }

5、删除（退栈）算法

1. int POPLINK( STLink  &top, SElemType  &item ){ 
2.     STLink p;
3.     if ( EMPTYS(top) ) 
4.         return 0;                  /* 删除失败*/
5.     else {
6.         p=top;                           /* 暂时保存栈顶结点的地址*/
7.         item=top->data;             /*保存被删栈顶的数据信息*/
8.         top=top->link;               /* 删除栈顶结点*/
9.         free(p);                         /* 释放被删除结点*/
10.         return 1;                       /* 删除成功*/
11.     }
12. }

堆栈的应用
1、符号匹配检查
2、数制转换
3、递归
4、表达式计算
5、迷宫