堆栈

时间 2019-11-07

标签堆栈繁體版

原文原文链接

1、什么是堆栈

计算机如何进行表达式求值？算法

例：算术表达式\(5+6/2-3*4\)，正确理解：\(5+6/2-3*4=5+3-3*4=8-3*4=8-12=-4\)数组

由两类对象构成的：
- 运算数，如\(二、三、4\)
- 运算符号，如\(+、-、*、/\)
不一样运算符号优先级不同

2、后缀表达式

中缀表达式：运算符号位于两个运算数之间。如，\(a+b*c-d/e\)
后缀表达式：运算符号位于两个运算数之间。如，\(abc*+de/-\)

例：\(62/3-42*+=?\)app

后缀表达式求值策略：从左向右“扫描”，逐个处理运算数和运算符号函数

遇到运算数怎么办？如何“记住”目前还不未参与运算的数？
遇到运算符号怎么办？对应的运算数是什么？

启示：须要有种存储方法，能顺序存储运算数，并在须要时“倒序”输出。性能

例：\(62/3-42*+=?\)spa

时间复杂性能：\(T(N)=O(N)\)3d

3、堆栈的抽象数据类型描述

堆栈（Strack）：具备必定操做约束的线性表，只在一端（栈顶，Top）作插入、删除指针

插入数据：入栈（Push）
删除数据：出栈（Pop）
后入先出：\(Last\,In\,First\,Out\)（LIFO）

类型名称：堆栈（Stack）code

数据对象集：一个有0个或多个元素的有穷线性表。

操做集：长度为\(MaxSize\)的堆栈\(s\in{Stack}\)，堆栈元素\(item\in{E}lementType\)

Stack CreateStack(int MaxSize)：生成空堆栈，其最大长度为\(MaxSize\)；
int IsFull(stack S, int MaxSize)：判断堆栈\(S\)是否已满；
void Push(Stack S， ElementType item)：将元素\(item\)压入堆栈；
int IsEmpty(Stack S)：判断堆栈\(S\)是否为空；
ElementType Pop(Stack S)：删除并返回栈顶元素；

\(Push\)和\(Pop\)能够穿插交替进行；

按照操做系列

Push(S,A),Push(S,B),Push(S,C),Pop(S),Pop(S,Pop(s)堆栈输出是：\(CBA\)
Push(S,A),Pop(S),Push(S,B),push(S,C),Pop(S),Pop(S)堆栈输出是：\(ACB\)

例：若是三个字符按\(ABC\)书序压入堆栈：\(ABC\)的全部排列不必定都是出栈的序列，没法产生\(CAB\)这样的序列。

4、栈的顺序存储实现

栈的顺序存储结构一般由一个一维数组和一个记录栈顶元素位置的变量组成。

/* c语言实现 */

# define Maxsize <储存数据元素的最大个数>
typedef struct SNode *Stack;
struct SNode{
  ElementType Data[MaxSize];
  int Top;
}

4.1 入栈

/* c语言实现 */

void Push(Stack PtrS, ElementType item)
{
  if(PtrS->Top == Maxsize-1){
    printf("堆栈满"); return;
  }else{
    PtrS->Data[++(PtrS->Top)] = item; /* 先+再返回 */
    return;
  }
}

4.2 出栈

/* c语言实现 */

ElementType Pop(Stack PtrS)
{
  if(PtrS->Top == -1){
    printf("堆栈空");，
    return ERROR; /* ERROR是ElementType的特殊值，标志错误 */
  }else
    return (PtrS->Data[(PtrS->Top)--]); /* 先返回再- */
}

5、例：请用一个数组实现两个堆栈，要求最大地利用数组空间，使数组只要有空间入栈操做就能够成功。

分析：一种比较聪明的方法是使这两个栈分别从数组的两头开始向中间生长；当两个栈的栈顶指针相遇时，表示两个栈都满了。

/* c语言实现 */

# define MaxSize <存储数据元素的最大个数>
struct DStack{
  ElementType Data[MaxSize];
  int Top1; /*堆栈1的栈顶指针 */
  int Top2; /*堆栈2的栈顶指针 */
} S;
S.Top1 = -1;
S.Top2 = MaxSize;

5.1 入栈

void Push(struct DStack *PtrS, ElementType item, int Tag)
{ /* Tag做为区分两个堆栈的标志，取值为1和2 */
  if (PtrS->Top2 - PtrS->Top1 == 1){ /*堆栈满*/
    printf("堆栈满"); return;
  }
  if (Tag == 1) /* 对第一个堆栈操做 */
    Ptrs->Data[++(PtrS->Top1)] = item;
  else /*对第二个堆栈操做 */
    Ptrs->Data[--(PtrS->Top2)] = item;
}

5.2 出栈

/* c语言实现 */

ElementType Pop(struct DStack *PtrS, int Tag)
{ /* Tag做为区分两个堆栈的标志，取值为1和2 */
  if （Tag == 1）{ /* 对第一个堆栈操做 */
    if (PtrS->Top1 == -1){ /* 堆栈1空 */
      printf("堆栈1空"); return NULL;
    } else return PtrS->Data[(PtrS->Top1)--];
  } else { /* 对第二个堆栈操做 */
    if (PtrS->Top2 == MaxSize){ /* 堆栈2空 */
      printf("堆栈2空"); return NULL;
    }else return PtrS->Data[(PtrS->Top2)++];
  }
}

6、堆栈的链式存储实现

栈的链式存储结构实际上就是一个单链表，叫作链栈。插入和删除操做只能在链栈的栈顶进行。栈顶指针Top应该在链表的开始；若是栈顶指针放在链表尾部，没法进行出栈操做，由于单链表出栈时找不到前一个结点。

/* c语言实现 */

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

6.1 堆栈初始化

/* c语言实现 */

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

6.2 判断堆栈S是否为空

/* c语言实现 */

int IsEmpty(Stack S)
{ /* 判断堆栈S是否为空，若为空函数返回整数1，不然返回0 */
  return (s->Nesxt == NULL);
}

6.3 入栈

/* c语言实现 */

void Push(ElementType item, Stack S)
{ /* 将元素item压入堆栈S */
  struct SNode *TmpCell;
  TmpCell = (struct SNode *)malloc(sizeof(struct SNode));
  TmpCell->ELement = item;
  TmpCell->Next = S->Next;
  S->Next = TmpCell;
}

6.4 出栈

牢记链表头才是栈顶

/* c语言实现 */

ElementType Pop(Stack S)
{ /* 删除并返回堆栈S的栈顶元素 */
  struct SNode *FirstCell;
  ElementType TopElem;
  if (IsEmpty(S)){
    printf("堆栈空"); return NULL;
  } else {
    FirstCell = S->Next;
    S->Next = FirstCell->Next;
    TopElem = FirstCell->Element;
    free(FirstCell);
    return TopElem;
  }
}

7、堆栈应用：表达式求值

回忆：应用堆栈实现后缀表达式求值的基本过程：从作到右读入后缀表达式的各项（运算符或运算数）

运算数：入栈；
运算符：从堆栈中弹出适当数量的运算数，计算并结果入栈；
最后，堆栈顶上的元素就是表达式的结果值。

8、中缀表达式求值

基本策略：将中缀表达式转换为后缀表达式，而后求值

如何将中缀表达式转换为后缀？

观察一个简单例子：\(2+9/3-5\quad->\quad{2\,9\,3/+5-}\)

运算数相对顺序不变
运算符号顺序发生改变
1. 须要存储“等待中”的运算符号
2. 要将当前运算符号与“等待中”的最后一个运算符号比较
考虑括号的状况

例：\(a*(b+c)/d=?\quad-->\quad{a}\,b\,c+*d/\)

注意：\((\)的优先级大于*，括号内的\(+\)的优先级大于括号外的*，遇到\()\)应该消除前一个\((\)

时间性能：\(T(N)=O(N)\)

9、中缀表达式如何转换为后缀表达式

从头至尾读取中缀表达式的每一个对象，对不一样对象按不一样的状况处理。

运算数：直接输出；
左括号：压入堆栈；
右括号：将栈顶的运算符弹出并输出，直到遇到左括号（出栈，不输出）；
运算符：
1. 若优先级大于栈顶运算符时，则把它压栈；
2. 若优先级小于等于栈顶运算符时，将栈顶运算符弹出并输出；再比较新的栈顶运算符，直到该运算符大于栈顶运算符优先级为止，而后将该运算符压栈；
若各对象处理完毕，则把堆栈中存留的运算符一并输出。

10、中缀转换为后缀实例

\((2*(9+6/3-5)+4)\)

11、堆栈的其余应用

函数调用及递归实现
深度优先搜索：图搜索
回溯算法：迷宫算法
......

12、Python实现-堆栈

# python语言实现

class Stack(object):
    def __init__(self):
        self.stack = []

    def push(self, value):  # 进栈
        self.stack.append(value)

    def pop(self):  # 出栈
        if self.stack:
            self.stack.pop()
        else:
            raise LookupError('stack is empty!')

    def is_empty(self):  # 若是栈为空
        return bool(self.stack)

    def top(self):
        # 取出目前stack中最新的元素
        return self.stack[-1]