【3】栈和队列-王道考研

目录

3.1 栈

3.1.1 栈的基本概念

3.1.2 栈的两种存储结构（顺序存储结构）

3.1.3 栈的两种存储结构（链式存储结构）

3.2 队列

3.2.1 队列的基本概念

3.2.2 队列的顺序存储结构

3.2.3 队列的链式存储结构

3.2.4 双端队列

3.2.5 知识总结

3.3 栈的应用

3.3.1 括号匹配（栈）

3.3.2  表达式求值（栈）

3.3.3 递归（栈）

3.4 数组

3.4.1 数组的定义

3.4.2 数组的存储结构

3.4.3 矩阵的压缩存储

3.5 本章总结

---

3.1 栈

3.1.1 栈的基本概念

• 受限的线性表

• 栈的基本操作

3.1.2 栈的两种存储结构（顺序存储结构）

• 只有top 和 MaxSize

• 判断栈空、栈长、栈满

• 进栈

• 出栈

• 共享栈

3.1.3 栈的两种存储结构（链式存储结构）

• 定义

• 基本操作：和单链表相同

3.2 队列

3.2.1 队列的基本概念

• 定义

• 基本操作

3.2.2 队列的顺序存储结构

• 双指针

• 基本操作

• 循环队列

 

3.2.3 队列的链式存储结构

 

• 栈和队列的输出序列

  • 出栈顺序

    • 
    • 

 

• 合法出栈序列的个数（按照最后的元素分类）
  • 根据出栈公式，1~k-1的元素必须再 k 前出栈，k+1~n的元素必须在 1~k-1 之后出栈
  • 
  • 对所有情况进行求和，使用递推公式推导，最终得到公式 f(n)=C(2n,n)/(n+1)
  • 

3.2.4 双端队列

• 定义
• 
• 变形为 ‘栈’
• 
• 变形为 ‘队列’
• 
• 受限的双端队列
• 

 

3.2.5 知识总结

 

3.3 栈的应用

3.3.1 括号匹配（栈）

# 栈--括号匹配

s='[(2)+([4+(5+6)])]'

stack=[]
brackets_l=['[','(','{']
brackets_r=[']',')','}']

def isMetaMatch(a,b):
    if brackets_l.index(a) == brackets_r.index(b):
        return True
    return False

def isMatch(s):
    for item in s:
        if item in brackets_l:
            stack.append(item)
        elif item in brackets_r:
            if isMetaMatch(stack[-1],item):
                stack.pop()
            else:
                print('invalid')
                return
    if len(stack)!=0:
        print('invalid')
    else:
        print('valid!')

if __name__=='__main__':
    isMatch(s)

3.3.2  表达式求值（栈）

# Infix  expression to Postfix expression
def is_super(a,b):
    if (a in ['*','/']) and (b in ['+','-']):
        return True
    else:
        return False

def expression_eval(s):
    stack=[]
    result=[]
    for item in s:
        if item=='(':
            stack.append(item)
        elif item==')':
            a=stack.pop()
            while a!='(':
                result.append(a)
                a=stack.pop()
        elif item in ['+','-','*','/']:
            if len(stack)==0:
                stack.append(item)
            elif stack[-1]=='(':
                stack.append(item)
            elif is_super(item,stack[-1]):
                stack.append(item)
            else:
                a = stack.pop()
                while is_super(item,a) or a=='(':
                    result.append(a)
        else:
            result.append(item)
    while len(stack)!=0:
        result.append(stack.pop())
    print(''.join(result))

if __name__=='__main__':
    s = '((A+B)*C)-(E-F)'
    expression_eval(s)

• 人书写的常常是中缀表达式，然而计算机常用后缀表达式求值，因此先要把中缀表达式继续转换
  • 
• 中缀表达式-->前缀表达式
  • 
• 中缀表达式-->后缀表达式
  • 
  • 

3.3.3 递归（栈）

• 递归的精髓

• 递归的问题
  • 栈溢出
  • 效率不高（重复计算较多）
  • 
  • 使用‘“栈”将递归程序转化为非递归程序 

# using recursion
def Fib(n):
    if n==0:
        return 0
    elif n==1:
        return 1
    else:
        return Fib(n-1)+Fib(n-2)

# using stack
def Fib2(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        stack = [0, 1]
        for i in range(2,n+1):
            p=stack.pop()
            pp=stack.pop()
            cur=p+pp
            stack.append(p)
            stack.append(cur)
        result=stack.pop()
        return result

s_Fib,s_Fib2=[],[]
for i in range(10):
    s_Fib.append(Fib(i))
    s_Fib2.append(Fib2(i))
print(s_Fib)
print(s_Fib2)

 

3.4 数组

3.4.1 数组的定义

• 定义
  • 
• 数组的维度
  • 二维数组就是数组中每个元素保存了一个数组
  • 
• 数组的维度和维界不可变
  • 

3.4.2 数组的存储结构

• 数据是一种逻辑概念：实际怎么存储的呢？
• 一维数组
  • 
• 二维数组
  • 按行存储
    • 
  • 按列存储
    • 

 

3.4.3 矩阵的压缩存储

• 对称矩阵
  • 
  • 
• 三角矩阵
  • 
  • 
  • 
• 三对角矩阵
  • 
• 稀疏矩阵
  • 

3.5 本章总结