力扣高频|算法面试题汇总(四）：堆、栈与队列

力扣高频|算法面试题汇总(一）：开始之前
力扣高频|算法面试题汇总(二）：字符串
力扣高频|算法面试题汇总(三）：数组
力扣高频|算法面试题汇总(四）：堆、栈与队列
力扣高频|算法面试题汇总(五）：链表
力扣高频|算法面试题汇总(六）：哈希与映射
力扣高频|算法面试题汇总(七）：树
力扣高频|算法面试题汇总(八）：排序与检索
力扣高频|算法面试题汇总(九）：动态规划
力扣高频|算法面试题汇总(十）：图论
力扣高频|算法面试题汇总(十一）：数学&位运算

力扣高频|算法面试题汇总(四）：堆、栈与队列

力扣链接
目录：

• 1.最小栈
• 2.数组中的第K个最大元素
• 3.数据流的中位数
• 4.有序矩阵中第K小的元素
• 5.前 K 个高频元素
• 6.滑动窗口最大值
• 7.基本计算器 II
• 8.扁平化嵌套列表迭代器
• 9.逆波兰表达式求值

1.最小栈

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
push(x) —— 将元素 x 推入栈中。
pop() —— 删除栈顶的元素。
top() —— 获取栈顶元素。
getMin() —— 检索栈中的最小元素。
示例:
输入：
[“MinStack”,“push”,“push”,“push”,“getMin”,“pop”,“top”,“getMin”]
[[],[-2],[0],[-3],[],[],[],[]]
输出：
[null,null,null,null,-3,null,0,-2]
解释：
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.getMin(); --> 返回 -2.
提示：
pop、top 和 getMin 操作总是在 非空栈 上调用。

C++

class MinStack {
private:
    vector<int> nums;
public:
    /** initialize your data structure here. */
    MinStack() {

    }
    
    void push(int x) {

        nums.push_back(x);
    }
    
    void pop() {
        nums.pop_back();
    }
    
    int top() {
        return nums[nums.size() - 1];
    }
    
    int getMin() {
        int min = nums[0];
        for(auto num : nums){
            if(num < min)
                min = num;
        }
        return min;
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(x);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */

Python

class MinStack:
    def __init__(self):
        """
        initialize your data structure here.
        """
        self.nums = []
    def push(self, x: int) -> None:
        self.nums.append(x)
    def pop(self) -> None:
        self.nums.pop()
    def top(self) -> int:
        return self.nums[len(self.nums) - 1]
    def getMin(self) -> int:
        min = self.nums[0]
        for num in self.nums:
            if num < min:
                min = num
        return min
# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(x)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin()

2.数组中的第K个最大元素

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
示例 1:
输入: [3,2,1,5,6,4] 和 k = 2
输出: 5
示例 2:
输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4
说明:
你可以假设 k 总是有效的，且 1 ≤ k ≤ 数组的长度。

思路1：
排序后查找。
使用默认排序算法的复杂度：算法的时间复杂度为 $O(NlogN)$，空间复杂度为 $O(1)$。
C++

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        sort(nums.begin(), nums.end());
        return nums[nums.size() - k];
    }
};

Python

class Solution:
    def findKthLargest(self, nums: List[int], k: int) -> int:
        nums = sorted(nums)
        return nums[len(nums) - k]

思路2:
参考官方思路，使用大顶堆，保留k个最大的数。
向大小为 k 的堆中添加元素的时间复杂度为$O(logk)$，我们将重复该操作 N 次，故总时间复杂度为 {O}(N \log k)O(Nlogk)。
在 Python 的 heapq 库中有一个 nlargest 方法，具有同样的时间复杂度，能将代码简化到只有一行。
C++

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        priority_queue<int,vector<int>,greater<int>> q;
        for(auto it:nums){
            q.push(it);
            if(q.size()>k) q.pop();
        }
        return q.top();
    }
};

Python

class Solution:
    def findKthLargest(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: int
        """
        return heapq.nlargest(k, nums)[-1]

3.数据流的中位数

中位数是有序列表中间的数。如果列表长度是偶数，中位数则是中间两个数的平均值。
例如，
[2,3,4] 的中位数是 3
[2,3] 的中位数是 (2 + 3) / 2 = 2.5
设计一个支持以下两种操作的数据结构：
void addNum(int num) - 从数据流中添加一个整数到数据结构中。
double findMedian() - 返回目前所有元素的中位数。
示例：
addNum(1)
addNum(2)
findMedian() -> 1.5
addNum(3)
findMedian() -> 2
进阶:
如果数据流中所有整数都在 0 到 100 范围内，你将如何优化你的算法？
如果数据流中 99% 的整数都在 0 到 100 范围内，你将如何优化你的算法？

思路1：
暴力法，每次获取中位数时就进行排序获取，超时。
思路2：
使用最大堆和最小堆，参考剑指offer：数据流中的中位数
C++

class MedianFinder {
private:
    // 最大堆
    vector<int> maxheap;
    // 最小堆
    vector<int> minheap;
public:
    /** initialize your data structure here. */
    MedianFinder() {
        
    }
    void addNum(int num) {
       int size = maxheap.size() + minheap.size();
        // 如果当前数目是偶数个，默认把num放进最小堆
        if((size & 1) == 0){
            int temp = num;
            //如果最大堆不为空，且输入的数字小于最大堆的最大值
            if(!maxheap.empty() && num < maxheap[0]){
                // 把最大的数字拿出来
                temp = maxheap[0];
                // 再把数字放进最大堆
                maxheap[0] = num;
                // 重新生成最大堆
                make_heap(maxheap.begin(), maxheap.end());
            }
            // 把元素放进最小堆
            minheap.push_back(temp);
            // 重新生成最小堆
            push_heap(minheap.begin(), minheap.end(), greater<int>());
        }else{// 如果当前数目是奇数个，默认把num放进最大堆
            int temp = num;
            // 如果最小堆不为空，且输入的数字大于最小堆的最小值
            if(!minheap.empty() && num > minheap[0]){
                temp = minheap[0]; // 把最小的数字拿出来
                minheap[0] = num; // 把输入的数字放进最小堆
                make_heap(minheap.begin(), minheap.end(), greater<int>());
            }
            // 把元素放进最大堆
            maxheap.push_back(temp);
            // 重新生成最大堆
            push_heap(maxheap.begin(), maxheap.end());
        }
    }
    
    double findMedian() {
        int size = maxheap.size() + minheap.size();
        double res;
        if(size & 1){
            res = minheap[0];
        }else{
            res = (maxheap[0] + minheap[0])*0.5;
        }
        return res;
    }
};

很迷，在最后一个测试用例超时了，所以参考官方实现。

class MedianFinder {
    priority_queue<int> maxheap;                              // 最大堆 降序
    priority_queue<int, vector<int>, greater<int>> minheap;   // 最小堆 升序

public:
    // Adds a number into the data structure.
    void addNum(int num)
    {
        maxheap.push(num);                                    // 把数字添加到最大堆中

        minheap.push(maxheap.top());                          // 把最大堆的最大值放进最小堆中
        maxheap.pop();                                        // 弹出最大堆最大值
        // 如果最大堆的元素个数小于最小堆的个数
        if (maxheap.size() < minheap.size()) {                // maintain size property
            maxheap.push(minheap.top());                      // 把最小堆的最小值放进最大堆
            minheap.pop();                                    // 弹出最小堆最小值
        }
    }
    // Returns the median of current data stream
    double findMedian()
    {   // 默认最大堆的元素个数大于最小堆元素个数 
        return maxheap.size() > minheap.size() ? (double) maxheap.top() : (maxheap.top() + minheap.top()) * 0.5;
    }
};

Python

class MedianFinder:
    def __init__(self):
        """
        initialize your data structure here.
        """
        self.minheap = [] # 最小堆
        self.maxheap = [] # 最大堆   
    def addNum(self, num: int) -> None:
        # 默认把元素添加到最大堆
        heapq.heappush(self.maxheap, (-num, num)) # python默认最小堆，模拟最大堆
        # 把最大堆最大值元素给最小堆
        heapq.heappush(self.minheap, self.maxheap[0][1])
        # 弹出最大堆的最大值
        heapq.heappop(self.maxheap)
        # 如果最大堆的元素个数少于最小堆数量，把最小堆的最小值给最大堆
        if len(self.maxheap) < len(self.minheap):
            heapq.heappush(self.maxheap, (-self.minheap[0], self.minheap[0]))
            heapq.heappop(self.minheap)
            
    def findMedian(self) -> float:
        size = len(self.minheap) + len(self.maxheap)
        # 如果是奇数
        if size & 1:
            return self.maxheap[0][1]
        else:
            return (self.maxheap[0][1] + self.minheap[0])*0.5

4.有序矩阵中第K小的元素

给定一个 n x n 矩阵，其中每行和每列元素均按升序排序，找到矩阵中第k小的元素。
请注意，它是排序后的第 k 小元素，而不是第 k 个不同的元素。
示例:
matrix = [
[ 1, 5, 9],
[10, 11, 13],
[12, 13, 15]
],
k = 8,
返回 13。
提示：
你可以假设 k 的值永远是有效的, 1 ≤ k ≤ n2 。

思路1：
使用堆排序，时间复杂度为$O(n^{2}log(k))$，空间复杂度为$O(k)$。用最大堆保存最小的k个数，堆顶就是第k小的数。由于矩阵大小是有顺序的，还可以有优化空间：如果该行元素大于堆顶，则可以直接中断该循环，因为不可能还存在比堆顶还小的元素，进入下一个循环。
C++

class Solution {
public:
    int kthSmallest(vector<vector<int>>& matrix, int k) {
        // 创建大顶堆，保存最小的k个元素
        priority_queue<int> maxheap; 
        for(int col = 0; col < matrix[0].size(); ++col)
            for(int row = 0; row < matrix.size(); ++row){
                if(maxheap.size() < k ){
                    // 放进元素
                    maxheap.push(matrix[row][col]);
                }else if(maxheap.top() > matrix[row][col]){// 如果矩阵元素小于最大堆的最大值
                    // 弹出最大值
                    maxheap.pop();
                    maxheap.push(matrix[row][col]); 
                }else{// 矩阵每行是从小到大，则右边的元素不可能还小于最大堆最大值
                    break;
                }
            }
        return maxheap.top();        
    }
};

Python

class Solution:
    def kthSmallest(self, matrix: List[List[int]], k: int) -> int:
        # 最大堆
        maxheap = [] # 最大堆  
        for row in range(len(matrix)):
            for col in range(len(matrix[0])):
                if len(maxheap) < k:
                    heapq.heappush(maxheap, (-matrix[row][col], matrix[row][col])) # python默认最小堆，模拟最大堆
                elif maxheap[0][1] > matrix[row][col]:
                    # 弹出最大堆的最大值
                    heapq.heappop(maxheap)
                    # 添加元素
                    heapq.heappush(maxheap, (-matrix[row][col], matrix[row][col]))
                else:
                    break
        return maxheap[0][1]

思路2：
二分法。参考思路如下：
首先第k大数一定落在[l, r]中，其中l = matrix[0][0], r = matrix[row - 1][col - 1].
我们二分值域[l, r]区间，mid = (l + r) >> 1, 对于mid，检查矩阵中有多少元素小于等于mid，记个数为cnt，那么有：

• 1、如果cnt < k, 那么[l, mid]中包含矩阵元素个数一定小于k，那么第k小元素一定不在[l, mid]中，必定在[mid +1, r]中，所以更新l = mid + 1.
• 2、否则cnt >= k，那么[l, mid]中包含矩阵元素个数就大于等于k，即第k小元素一定在[l,mid]区间中，更新r = mid;

算法时间复杂度为$O(n\ast log(m))$, 其中n = max(row, col)，代表矩阵行数和列数的最大值, m代表二分区间的长度，即矩阵最大值和最小值的差。
C++

class Solution {
public:
    int kthSmallest(vector<vector<int>>& matrix, int k) {
        int rows = matrix.size();
        int cols = matrix[0].size();
        // 使用二分法
        int low = matrix[0][0];
        int high = matrix[rows - 1][cols - 1];
        while(low < high){
            int mid = low + (high - low)/2;
            int count = findCount(matrix, mid);
            // 如果比mid小的数字小于k, 说明第k小的数字大于当前mid
            if(count < k)
                low = mid + 1;
            else
                high = mid;      
        }
        return low;  
    }
    int findCount(vector<vector<int>>& matrix, int mid){
        // 利用矩阵特性从左小角开始查找
        int count = 0;
        int rows = matrix.size();
        int cols = matrix[0].size();
        int row = rows-1;
        int col = 0;
        while( row >= 0 && col <= cols - 1){
            if(matrix[row][col] > mid){
                // 先减行数
                --row;
            }else{// 跳过这一列
                count += row+1;
                // 移动
                ++col;
            }
        }
        return count;   
    }
};

Python

class Solution:
    def kthSmallest(self, matrix: List[List[int]], k: int) -> int:
        # 二分法
        low = matrix[0][0]
        rows = len(matrix)
        cols = len(matrix[0])
        high = matrix[rows - 1][cols - 1]
        while low < high:
            mid = low + (high - low)/2
            count = self.findCount(matrix , mid)
            if count < k:
                low = mid + 1
            else:
                high = mid
        return int(low)
    def findCount(self, matrix , mid):
            rows = len(matrix)
            cols = len(matrix[0])
            col = 0
            row = rows - 1
            count = 0
            while row >= 0 and col <= cols - 1:
                if matrix[row][col] > mid:
                    row -= 1
                else:
                    count += row + 1
                    col += 1
            return count               

5.前 K 个高频元素

给定一个非空的整数数组，返回其中出现频率前 k 高的元素。
示例 1:
输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]
示例 2:
输入: nums = [1], k = 1
输出: [1]
提示：
你可以假设给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。
你的算法的时间复杂度必须优于 O(n log n) , n 是数组的大小。
题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的。
你可以按任意顺序返回答案。

思路：
首先使用哈希表记录每个数字出现的频率，解这使用最小堆进行存储数字出现的频率，用来保存前k个高频元素出现的频率。
C++

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        // 用哈希表存储每个id出现的次数
        unordered_map<int, int> idCount;
        for(auto num : nums){
            if(idCount.find(num) == idCount.end())
                idCount[num] = 1;
            else
                ++idCount[num];         
        }
        // 使用最小堆来保存出现频率最高的k个元素
        vector<int> minheap;
        
        for(auto x : idCount){
            minheap.push_back(x.second);
            // 当已建堆的容器范围内有新的元素插入末尾后，应当调用push_heap将该元素插入堆中。
            push_heap(minheap.begin(), minheap.end(), greater<int>());
            if(minheap.size() > k){
                // 将堆顶(所给范围的最前面)元素移动到所给范围的最后，并且将新的最小值置于所给范围的最前面
                pop_heap(minheap.begin(), minheap.end(), greater<int>());
                // 弹出最小堆最小的那个元素
                minheap.pop_back();
            }
        }
        vector<int> ans;
        for(auto x : idCount){
            // 在最小堆中招对应的id，以及保证结果不存在这个数字，以免重复记录
            if(find(minheap.begin(), minheap.end(), x.second) != minheap.end() && find(ans.begin(), ans.end(), x.first) == ans.end()){
                ans.push_back(x.first);
            }
        }
        return ans;
    }
};

Python：

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        idHash = dict()
        for num in nums:
            if not num in idHash:
                idHash[num] = 1
            else:
                idHash[num] += 1
        # 建立最小堆 
        minheap = []
        for key in idHash:
            
            heapq.heappush(minheap, (idHash[key], key))
            if len(minheap) > k:
                # 弹出
                heapq.heappop(minheap)
                # 变最小堆
                # heapq.heapify(minheap)
                
        ans = []
        for value, key in minheap:
            ans.append(key)
        
        return ans

6.滑动窗口最大值

给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
返回滑动窗口中的最大值。
进阶：
你能在线性时间复杂度内解决此题吗？
示例:
输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
输出: [3,3,5,5,6,7]
解释:
滑动窗口的位置 最大值
[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5] 3 6 7 5
1 3 -1 [-3 5 3] 6 7 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7
提示：
1 <= nums.length <= 10^5
-10^4 <= nums[i] <= 10^4
1 <= k <= nums.length

这题剑指offer做过，具体思路见剑指offer|解析和答案(C++/Python) (五)上：滑动窗口最大值
C++

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> maxvalue;
        // 新建队列进行保存最大值的索引
        deque<int> index;
        for(int i = 0; i < k; ++i){
            // 确保索引的值是保留的最大值
            while(!index.empty() && nums[i]>= nums[index.back()])
                index.pop_back();
            // 添加索引
            index.push_back(i);
        }
        for(int i = k; i < nums.size(); ++i){
            // 添加最大值
            maxvalue.push_back(nums[index.front()]);
            // 确保索引的值是保留的最大值
            while(!index.empty() && nums[i]>= nums[index.back()])
                index.pop_back();
            // 如果最大值溢出滑动框
            if(!index.empty() && index.front() <= (i - k))
                index.pop_front();
            index.push_back(i);
        }
        // 加入最后一个值
        maxvalue.push_back(nums[index.front()]);
        return maxvalue;
    }
};

Python

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        maxValue = list()
        if len(nums) > 0 and k > 0:
            index = []
            for i in range(k):
                while len(index) > 0 and nums[i] >= nums[index[-1]]:
                    index.pop()
                index.append(i)
                
            for i in range(k, len(nums)):
                maxValue.append(nums[index[0]])
                while len(index) > 0 and nums[i] >= nums[index[-1]]:
                    index.pop()
                if len(index) > 0 and index[0] <= (i-k):
                    index.pop(0)
                index.append(i)
            maxValue.append(nums[index[0]])
        return maxValue

7.基本计算器 II

实现一个基本的计算器来计算一个简单的字符串表达式的值。
字符串表达式仅包含非负整数，+， - ，，/ 四种运算符和空格 。 整数除法仅保留整数部分。
示例 1:
输入: "3+22"
输出: 7
示例 2:
输入: " 3/2 "
输出: 1
示例 3:
输入: " 3+5 / 2 "
输出: 5
说明：
你可以假设所给定的表达式都是有效的。
请不要使用内置的库函数 eval。

思路：
参考使用栈的方式来保存计算结果。利用栈的方式解决运算优先级的问题 当为加减时放入栈中 当为乘除时讲栈顶元素与最近获得一个数进行运算，同时把栈顶元素弹出，放进计算之后的元素。最后把栈的所有元素加起来即可。
C++

class Solution {
public:
    int calculate(string s) {
        long result = 0;
        long num = 0;
        // 初始上一个运算符为加法 上个数字为0
        char op = '+';
        char c;
        // 用栈来保存结果
        vector<int> stack;
        for(int i = 0; i < s.length(); ++i){
            c = s[i];
            if(c >='0'){
                // 计算数字
                num = num * 10 + c- '0';
            }
            // 当遇到符号时，或者是到了字符串末尾
            if(c < '0' && c != ' '|| i == s.length() -1){
                // 此时op是上一次遇到的符号
                if(op == '+') stack.push_back(num);
                if(op == '-') stack.push_back(-num);
                if(op == '*' || op =='/'){
                    int temp = (op == '*')? stack.back() * num : stack.back()/num;
                    // 弹出上一个值
                    stack.pop_back();
                    // 重新放进计算的结果
                    stack.push_back(temp);       
                }
                // 获取当前op符号
                op = s[i];
                num = 0;
            }
        }
        while(!stack.empty()){
            result += stack.back();
            stack.pop_back();
        }
        return result;       
    }
};

Python

class Solution:
    def calculate(self, s: str) -> int:
        stack = []
        num = 0
        res = 0
        op = '+'
        ops = ['+', '-', '*', '/']
        for i in range(len(s)):
            # s[i] != ' ' 很重要
            if not s[i] in ops and  s[i] != ' ':
                num = num*10 + int(s[i]) 
            if s[i] in ops and s[i] != ' ' or i == len(s) - 1:
                if op == '+':
                    stack.append(num)
                if op == '-':
                    stack.append(-num)
                if op == '*' :
                    temp = stack[-1]*num 
                    stack.pop()
                    stack.append(int(temp))
                if op == '/':
                    temp = stack[-1]/num 
                    stack.pop()
                    stack.append(int(temp))                            
                num = 0
                op = s[i]
        for num in stack:
            res += num
            
        return res

8.扁平化嵌套列表迭代器

扁平化嵌套列表迭代器
给你一个嵌套的整型列表。请你设计一个迭代器，使其能够遍历这个整型列表中的所有整数。
列表中的每一项或者为一个整数，或者是另一个列表。其中列表的元素也可能是整数或是其他列表。
示例 1:
输入: [[1,1],2,[1,1]]
输出: [1,1,2,1,1]
解释: 通过重复调用 next 直到 hasNext 返回 false，next 返回的元素的顺序应该是: [1,1,2,1,1]。
示例 2:
输入: [1,[4,[6]]]
输出: [1,4,6]
解释: 通过重复调用 next 直到 hasNext 返回 false，next 返回的元素的顺序应该是: [1,4,6]。

这题没怎么看明白，先放一下。
C++

class NestedIterator {
private:
    stack<NestedInteger> s;
public:
    NestedIterator(vector<NestedInteger> &nestedList) {
        // 添加元素
        for(int i = nestedList.size() - 1; i >= 0; --i)
            s.push(nestedList[i]);
    }
    
    int next() {
        NestedInteger temp = s.top(); // 获取栈顶元素
        s.pop(); // 弹出栈顶
        return temp.getInteger();
    }
    
    bool hasNext() {
        while(!s.empty()){
            NestedInteger temp = s.top();
            if(temp.isInteger())
                return true;
            s.pop();
            for(int i = temp.getList().size() - 1; i >= 0; --i)
                s.push(temp.getList()[i]);
        }
        return false;
    }
};

还有其他思路:C++ 综合各路大佬的答案
Python:
来自：栈+迭代，5行代码简单易理解

class NestedIterator:
    def __init__(self, nestedList: [NestedInteger]):
        # 对于nestedList中的内容，我们需要从左往右遍历，
        # 但堆栈pop是从右端开始，所以我们压栈的时候需要将nestedList反转再压栈
        self.stack = nestedList[::-1]

    def next(self) -> int:
        # hasNext 函数中已经保证栈顶是integer，所以直接返回pop结果
        return self.stack.pop(-1).getInteger()

    def hasNext(self) -> bool: 
        # 对栈顶进行‘剥皮’，如果栈顶是List，把List反转再依次压栈，
        # 然后再看栈顶，依次循环直到栈顶为Integer。
        # 同时可以处理空的List，类似[[[]],[]]这种test case           
        while len(self.stack) > 0 and self.stack[-1].isInteger() is False:
            self.stack += self.stack.pop().getList()[::-1]
        return len(self.stack) > 0

9.逆波兰表达式求值

根据逆波兰表示法，求表达式的值。
有效的运算符包括 +, -, , / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。
说明：
整数除法只保留整数部分。
给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。
示例 1：
输入: [“2”, “1”, “+”, “3”, ""]
输出: 9
解释: ((2 + 1) * 3) = 9
示例 2：
输入: [“4”, “13”, “5”, “/”, “+”]
输出: 6
解释: (4 + (13 / 5)) = 6

思路：
这个在《大话数据结构上》看到过。使用栈数据结构。规则:从左到右遍历表达式的每个数字和符号，遇到是数字就进栈，遇到是符号，就将处于栈顶的两个数字弹出，进行运算，运算结果进钱， 直到最终获得结果。
举例后缀表达式：931 - 3*+102 / +，以下图片来自《大话数据结构上》：

C++

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        // 用栈来存储数字
        vector<int> nums;
        for(int i = 0; i < tokens.size(); ++i){
            if(tokens[i] != "+" && tokens[i] != "-" && tokens[i] != "*" && tokens[i] != "/"){
                nums.push_back(stoi(tokens[i]));
            }else if(tokens[i] == "+"){
                int add1 = nums.back();
                nums.pop_back();
                int add2 = nums.back();
                nums.pop_back();
                add2 = add2 + add1;
                nums.push_back(add2);
            }else if(tokens[i] == "-"){
                int sub1 = nums.back();
                nums.pop_back();
                int sub2 = nums.back();
                nums.pop_back();
                sub2 = sub2 - sub1;
                nums.push_back(sub2);
            }else if(tokens[i] == "*"){
                int mul1 = nums.back();
                nums.pop_back();
                int mul2 = nums.back();
                nums.pop_back();    
                mul2 = mul2 * mul1;
                nums.push_back(mul2);
            }else if(tokens[i] == "/"){
                int div1 = nums.back();
                nums.pop_back();
                int div2 = nums.back();
                nums.pop_back();
                div2 = div2 / div1;
                nums.push_back(div2);
            }       
        }
    return nums[0];
    }
};

还有范例，很优美：

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        if(tokens.size()==0) return 0;
        stack<int> s;
        int temp=0;
        for(int i=0;i<tokens.size();i++){
            if(tokens[i][0]<='9'&&tokens[i][0]>='0'||(tokens[i].size()>1&&tokens[i][0]=='-')){
                s.push(atoi(tokens[i].c_str()));
            }else{
                int a=s.top();
                s.pop();
                int b=s.top();
                s.pop();
                if(tokens[i][0]=='+') temp=a+b;
                if(tokens[i][0]=='-') temp=b-a;
                if(tokens[i][0]=='*') temp=a*b;
                if(tokens[i][0]=='/') temp=b/a;
                s.push(temp);
            }
        }
        return s.top();
    }
};

Python：

class Solution:
    def evalRPN(self, tokens: List[str]) -> int:            
        nums = []
        ops = ["+", "-", "*", "/"]
        for i in range(len(tokens)):
            if not tokens[i] in ops:
                nums.append(int(tokens[i]))
            elif tokens[i] == "+":
                add1, add2 = nums[-2], nums[-1]
                nums.pop()
                nums.pop()
                add1 = add1 + add2
                nums.append(int(add1))
            elif tokens[i] == "-":
                sub1, sub2 = nums[-2], nums[-1]
                nums.pop()
                nums.pop()
                sub1 = sub1 - sub2
                nums.append(int(sub1))
            elif tokens[i] == "*":
                mul1, mul2 = nums[-2], nums[-1]
                nums.pop()
                nums.pop()
                mul1 = mul1 * mul2
                nums.append(int(mul1))
            elif tokens[i] == "/":
                div1, div2 = nums[-2], nums[-1]
                nums.pop()
                nums.pop()
                div1 = div1 / div2
                nums.append(int(div1))
        return nums[0]