数据结构 3. 栈

一、栈

1.栈的定义

栈是一种“先进后出”的一种数据结构，有压栈出栈两种操作方式。如下图：

栈的实现

2.1 用数组实现一个顺序栈

class StackUnderflow(ValueError): # 栈下溢（空栈访问）
    pass
class SStack():             # 基于顺序表技术实现的栈类
    def __init__(self):     # 用list对象 _elems存储栈中元素
        self._elems = []    # 所有栈操作都映射到list操作
    
    def is_empty(self):
        return self._elems == []
    
    def top(self):
        if self._elems == []:
            raise StackUnderflow("in SStack.top()")
        return self._elems[-1]
    
    def push(self, elems):
        self._elems.append(elem)
        
    def pop(self):
        if self._elems == []:
            raise StackUnderflow("in SStack.top()")
        return self._elems.pop()

2.2 用链表实现一个链式栈

class LNode:   # 定义节点类
    def __init__(self, elem, next_=None):
        self.elem = elem
        self.next = next_
        
class LStack():
    def __init__(self):
        self._top = None

    def is_empty(self):
        return self._top is None

    def top(self):
        if self._top is None:
            raise StackUnderflow("in LStack.top")
        return self._top.elem

    def push(self,elem):
        self._top = LNode(elem, self._top)

    def pop(self):
        if self._top is None:
            raise StackUnderflow("in LStack.pop")
        p = self._top
        self._top = p.next
        return p.elem

2.3 编程模拟实现一个浏览器的前进、后退功能

'''利用双向链表实现'''
class page(object):
    '''加载一个页面'''
    def __init__(self, item, prev_=None, next_=None):
        self.item = item
        self.prev = prev_
        self.next = next_
        
        
class History(object):
    def __init__(self):
        self._cur = page(None)
        
    def loadPage(self,newPage):
        '''加载新的页面'''
        p = page(newPage, self._cur,None)
        self._cur.next = p
        self._cur = self._cur.next
        return self._cur.item
    
    def back(self):
        '''返回上一个页面'''
        if self._cur.prev is None:
            return
        self._cur = self._cur.prev
        return self._cur.item
    
    def forward(self):
        '''前进一个页面'''
        if self._cur.next is None:
            return
        self._cur = self._cur.next
        return self._cur.item
    
if __name__ == '__main__':
    h = History()
    print('加载页面:{}'.format(h.loadPage('网页1')))
    print('加载页面:{}'.format(h.loadPage('网页2')))
    print('返回页面:{}'.format(h.back()))
    print('前进页面:{}'.format(h.forward()))

4.实现求链表的中间结点

def find_middle_node(head):
    slow, fast = head, head
    while fast and fast.next:
        fast = fast.next.next
        slow = slow.next
    return slow

练习

20. 有效的括号

[https://leetcode-cn.com/problems/valid-parentheses/]
题目描述
给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。

注意空字符串可被认为是有效字符串。
示例 1:

输入: “()”
输出: true

示例2：

输入: “()[]{}”
输出: true

示例3：

输入: “(]”
输出: false

示例 4:

输入: “([)]”
输出: false

示例 5:

输入: “{[]}”
输出: true

解题思路
运用栈的思想，遍历输入的字符串，当是左括号时，进行push向栈中添加遍历到的左括号；当遍历到的元素为右括号时，判断其与栈顶的左括号是否对应，如果对应则进行pop去除栈顶元素，反之终止遍历。最后如果stack为空则是有效括号，返回True。

代码实现

class Solution:
    def isValid(self, s: str) -> bool:
        stack = []
        paren_map = {')':'(', '}':'{',']':'['}
        for c in s:
            if c not in paren_map: # 如果c是左括号
                stack.append(c)
            elif not stack or paren_map[c] !=stack.pop(): # 如果栈是空的或元素与栈顶不匹配则返回False
                return False
        return not stack # 如果非空则返回False
        

32. 最长有效括号

[https://leetcode-cn.com/problems/longest-valid-parentheses/]
题目描述
给定一个只包含 ‘(’ 和 ‘)’ 的字符串，找出最长的包含有效括号的子串的长度。

示例 1:

输入: “(()”
输出: 2
解释: 最长有效括号子串为 “()”

示例 2:

输入: “)()())”
输出: 4
解释: 最长有效括号子串为 “()()”

解题思路
网上的最有解法用的是动态规划的思想：
dp 方法:
我们用 dp[i] 表示以 i 结尾的最长有效括号；

1. 当s[i] 为(,dp[i] 必然等于0,因为不可能组成有效的括号;

2. 那么s[i] 为 )

   2.1 当 s[i-1] 为 (，那么 dp[i] = dp[i-2] + 2；

   2.2 当 s[i-1] 为 ) 并且 s[i-dp[i-1] - 1] 为 (，那么 dp[i] = dp[i-1] + 2 + dp[i-dp[i-1]-2]；

时间复杂度：O(n)O(n)

代码实现

class Solution:
    def longestValidParentheses(self, s: str) -> int:
        n = len(s)
        if n == 0: return 0
        dp = [0] * n
        res = 0
        for i in range(n):
            if i>0 and s[i] == ")":
                if  s[i - 1] == "(":
                    dp[i] = dp[i - 2] + 2
                elif s[i - 1] == ")" and i - dp[i - 1] - 1 >= 0 and s[i - dp[i - 1] - 1] == "(":
                    dp[i] = dp[i - 1] + 2 + dp[i - dp[i - 1] - 2]
                if dp[i] > res:
                    res = dp[i]
        return res

150. 逆波兰表达式求值

[https://leetcode-cn.com/problems/evaluate-reverse-polish-notation/]
题目描述
根据逆波兰表示法，求表达式的值。

有效的运算符包括 +, -, *, / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

说明：

• 整数除法只保留整数部分。
• 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1：

输入: [“2”, “1”, “+”, “3”, “*”]
输出: 9
解释: ((2 + 1) * 3) = 9

示例 2：

输入: [“4”, “13”, “5”, “/”, “+”]
输出: 6
解释: (4 + (13 / 5)) = 6

示例 3：

输入: [“10”, “6”, “9”, “3”, “+”, “-11”, “", “/”, "”, “17”, “+”, “5”, “+”]
输出: 22
解释:
((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

解题思路
运用栈的思想，遍历给定的列表，当元素为数字（即非运算符）时，对栈进行push操作，将元素加入栈中；当元素为运算符时，则对栈进行pop操作，将取出的两个元素进行响应的运算，将运算结果放入栈中。继续遍历下一个元素。

代码实现

class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        f1 = lambda a,b:a+b
        f2 = lambda a,b:a-b
        f3 = lambda a,b:a*b
        f4 = lambda a,b:int(a/b)
        maps = {'+':f1,'-':f2,'*':f3,'/':f4}
        stack = []
        for i in tokens:
            if i in maps:
                a = stack.pop()
                b = stack.pop()
                stack.append(maps[i](b,a))
            else:
                i = int(i)
                stack.append(i)
        return stack[-1]