数据结构之栈

本文以《大话数据结构》为基础进行书写

---

栈的基本说明

 栈(stack)是限定仅在表尾进行插入和删除操作的线性表—又称后进先出(Last In First Out)的线性表（LIFO结构）。把允许插入和删除的一端称为栈顶(top)，另一端则为栈底(bottom),不含任何数据元素的栈称为空栈。
 栈的插入操作，叫做进栈，或压栈、入栈；删除操作叫出栈，或弹栈。
 栈既有顺序存储结构和链式存储结构，它们在时间复杂度上都是一样的，均为O(1)。对于空间性能，如果栈的使用过程中元素变化不可预料，有时很小，有时很大，则最好使用链栈，反之如果它的变化在可控范围内，则使用顺序栈会更好些。

栈的抽象数据类型：

ADT 栈(stack)
Data
  同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系。
Operation 
  InitStack(* S): 初始化操作，建立一个空栈S；
  DestroyStack(* S): 若栈存在，则销毁它；
  ClearStack(* S): 将栈清空；
  StackEmpty( S ): 若栈为空，返回true，否则返回false；
  GetTop(S, *e)： 若栈存在且非空，用 e 返回S的栈顶元素；
  Push(*S,e)：若栈存在，插入新元素e到栈S中并成为栈顶元素；
  Pop（*S，*e):删除栈S中栈顶元素，并用e返回其值；
  StackLength(S): 返回栈S的元素个数
endADT

栈的顺序存储结构

 进行进栈Push和出栈Pop时，同样需要优先考虑异常情况，然后再进行进出操作

栈的结构代码：

typedef int SElemType;  /*定义SElemType类型，根据需求设置*/
typedef struct
{
  SElemType data[MAXSIZE];
  int top;    /*用于栈顶指针*/
}SqStack;

进栈Push：

Status Push( SqStack  *S, SElemType e)
{
 /*MAXSIZE为数组元素个数，但下标从0开始，
 所以(MAXSIZE -1) 表示最后一个元素位置*/
  if(S->top == MAXSIZE -1)     
  {
    return ERROR;
  }
  //栈顶指针增加 1 
  S->top++;                 
  //将新插入元素赋值给栈顶空间
  S->data[S->top] = e; 
  return OK;
}

出栈Pop：

/*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR*/
Status Pop(SqStack *S, SElemType *e)
{
  if(S->top == -1)
  {
    return ERROR;
  }
  //将要删除的栈顶元素赋值给e
  *e = S->data[S->top];   
  //栈顶指针减一
  S->top--;                       
  return OK;
}

其他顺序存储栈结构

两栈共享空间

 在两个栈的空间需求有相反关系时，也就是一个栈增长时另一个栈在缩短的情况，并且两个具有相同数据类型的栈，可以用下面的操作来节省空间。

 数组有两个断点，让一个栈的栈底为数组的始端，即下标为0处；另一个栈为数组的末端，即下标为数组长度（n-1）处。这样两个栈增加元素，就是两个栈顶向中间靠拢。
 何时栈满？找极端情况，若栈1(左边的栈)为空时，就是top1等于(-1)时；而当top2等于 n 时，即是栈 2 为空。则如果栈2是空栈，且栈1的top1等于(n-1)时，就是栈1满了，反之栈1为空栈且栈2的top2等于0时，为栈2满。可推导出两个栈顶见面时，就是两个指针之间相差1时，即top1+1 == top2时为栈满。

/*两栈共享空间结构*/
typedef struct
{
      SElemType data[MAXSIZE];
      int top1;    /*栈1栈顶指针*/
      int top2;    /*栈2栈顶指针*/
}SqDoubleStack;

进栈Push：

 增加一个判断当前操作是栈1还是栈2的参数stackNumber。

/*插入元素e为新的栈顶元素*/
Status Push(SqDoubleStack *S, SElemType e, int stackNumber)
{
  /*栈已满，不能再push新元素了*/
  if(S->top1+1 == S->top2)  
  {
    return ERROR；
  }
  /*栈1有元素进栈*/
  if(stackNumber == 1)  
  {
    /*若栈1则先top1+1后给数组元素赋值*/
    S->data[++S->top1] = e;    
  }             
  else if(stackNumber == 2)         /*栈2有元素进栈*/
  {
    /*若栈2则先top2-1后给数组元素赋值*/
    S->data[--S->top2] = e;   
  }   
  return OK;
}

出栈Pop：

 增加一个判断当前操作是栈1还是栈2的参数stackNumber。

Status Pop(SqDoubleStack *S, SElemType *e, int stackNumber)
{
  if(stackNumber == 1)
  {
    if(S->top1 == -1)
    {
      return ERROR;           /*栈1为空栈，溢出*/
    }
    *e = S->data[S->top1--];   /*将栈1的栈元素出栈*/
   }
   else if (stackNumber == 2)
   {
     if(S->top2 == MAXSIZE)
     {
       return ERROR;          /*栈2为空栈，溢出*/
     }
     *e = S->data[S->top2++]； /*将栈2的栈元素出栈*/
   }
   retutn OK;
}

栈的链式存储结构（链栈）：

 对于链栈来说，基本不存在栈满的情况，除非内存已经没有可以使用的空间。链栈的空其实就是top = NULL；

链栈的结构代码：

typedef struct StackNode
{
     SElemType data;
     struct StackNode *next;
}StackNode, *LinkStackPtr;

typedfe struct LinkStack
{
      LinkStackPtr top;
      int count;
}LinkStack;

进栈Push：

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

/*插入元素e为新的栈顶元素*/
Status Push(LinkStack *S, SElemType e)
{
  LinkStackPtr s=(LinkStackPtr)malloc(sizeof(StackNode));
  s->data = e;
  /*把当前的栈顶元素赋值给新结点的直接后继，如1*/
  s->next = S->top;  
  /*将新的结点s赋值给栈顶指针，如图中2*/
  S->top = S;      
  S->count++;
  return OK;
}

出栈Pop：

 假设变量p用来存储要删除的栈顶结点，将栈顶指针下移一位，最后释放p即可。

/*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR*/
Status Pop(LinkStack *S, SElemType *e)
{
  LinkStackPtr p;
  if(StackEmpty(* S))
  {
    return ERROR;
  }
  *e = S->top->data;
  /*将栈顶结点赋值给p，如3*/
  p=S->top;                  
  /*使得栈顶指针下移一位，指向后一结点，如4*/
  S->top=S->top->next; 
  /*释放结点p*/
  free(p);                         
  S->count--;
  return OK;
}

栈的应用

 栈的引入简化了程序设计的问题，划分了不同关注层次，使得思考范围缩小，更加聚焦于我们要解决的核心。
四则运算表达式求值：
 以中缀表示法表示的{9+(3-1) * 3 + 10/2}为例。

1. 将中缀表达式转化为后缀表达式—逆波兰表示法（栈用来进出运算的符号） {9+(3-1) * 3 + 10/2} --> {9 3 1 - 3 *+10 2/+}
 规则：从左到右遍历中缀表达式的每个数字和符号，若是数字就输出，即成为后缀表达式的一部分；若是符号，则判断其与栈顶符号的优先级，是右括号或优先级低于栈顶符号（乘除优先加减），则栈顶元素依次出栈并输出，并将当前符号进栈，一直到最终输出后缀表达式为止。

图解说明：
 a.初始化一空栈，用来对符号进出栈使用。如图4-9-6的左图所示。
 b.第一个字符是数字9,输出9，后面是符号“+”，进栈。如图4-9-6的右图所示。

 c.第三个字符是"(“, 依然是符号，因其只是左括号，还未配对，故进栈。如图4-9-7的左图所示。
 d.第四个字符是数字3，输出，总表达式为9 3，接着是”-“，进栈。如图4-9-7的右图所示。

 e.接着是数字1，输出，总表达式为9 3 1，后面是符号”)“，此时，我们需要去匹配此前的”(“,所以栈顶依次出栈，并输出，直到”(“出栈为止。总的输出表达式为9 3 1 -。如图4-9-8的左图所示。
 f.接着是数字3，输出，总的表达式为9 3 1 - 3.紧接着是符号”“，因为此时的栈顶符号为”+“号，优先级低于”“，因此不输出，”“进栈。如图4-9-8的右图所示。

  g.之后是符号”+“,此时当前栈顶元素”“比这个”+“的优先级高，因此栈中元素出栈并输出（没有比”+“号更低的优先级，所以全部出栈)，总输出表达式为9 3 1 - 3* +。然后将当前这个符号”+“进栈。
 h.紧接着数字10，输出，总表达式变为9 3 1 - 3 * + 10。后是符号”/“,进栈。如图4-9-9的右图所示。

 i.最后一个数字2，输出，总的表达式为9 3 1 - 3* + 10 2。如图4-9-10的左图所示。
 j.因已经到最后，所以将栈中符号全部出栈并输出。最终输出的后缀表达式结果为9 3 1- 3*+10 2 / +。如图4-9-10的右图所示。

2. 将后缀表达式进行运算得出结果（栈用来进出运算的数字）
 规则：从左到右遍历表达式的每个数字和符号，遇到是数字就进栈，遇到的是符号，就将处于栈顶两个数字出栈，进行运算，运算结果出栈，一直到最终获得结果。
 a.初始化一个空栈。此栈用来对要运算的数字进出使用。如图4-9-1的左图所示。
 b.后缀表达式中前三个都是数字，所以9、3、1进栈，如图4-9-1的右图所示。

  c.接下来是”-"，所以将栈中的1出栈作为减数，3出栈作为被减数，并运算3-1得到2，再将2进栈，如图4-9-2的左图所示。(遇到符号则从栈顶向下取两个数值，更下面的放左边，栈顶元素放右边)。
 d.接着是数字3进栈，如图4-9-2的右图所示。

 e.后面是"*“，也就意味着栈中3和2出栈，2与3相乘，得到6，将6进栈，如图4-9-3的左图所示。
 f.下面是”+“,所以栈中6和9出栈，9与6相加，得到15，将15进栈，如图4-9-3的右图所示。

 g.接着是10与2两数字进栈，如图4-9-4的左图所示。
 h.接着是符号”/“,因此，栈顶的2与10出栈，10与2相除，得到5，将5进栈，如图4-9-4的右图所示。

 i.最后一个是符号”+",所以15与5出栈并相加，得到20，将20进栈，如图4-9-5的左图所示。
 j.结果是20出栈，栈变为空，如图4-9-5的右图所示。