算法练习-栈和队列(二)

1.计算器

链接：https://leetcode.cn/problems/calculator-lcci

1.1 题目

给定一个包含正整数、加(+)、减(-)、乘(*)、除(/)的算数表达式(括号除外)，计算其结果。

表达式仅包含非负整数，+， - ，*，/ 四种运算符和空格 。 整数除法仅保留整数部分。

示例 1:

输入: “3+2*2”
输出: 7
示例 2:

输入: " 3/2 "
输出: 1
示例 3:

输入: " 3+5 / 2 "
输出: 5

1.2 题解

创建了两个栈，一个存储运算数，另一个存储运算符

如何进行入栈和出栈，见prior

class Solution {
    public int calculate(String s) {
        Stack<Integer> nums = new Stack<>();
        Stack<Character> ops = new Stack<>();
        int i = 0;
        int n = s.length();
        while (i < n) {
            char c = s.charAt(i);
            if (c == ' ') {
                i++;
            } else if (isDigit(c)) {
                int num = 0;
                while (i < n && isDigit(s.charAt(i))) {
                    num = num * 10 + (s.charAt(i) - '0');
                    i++;
                }
                nums.push(num);
            } else {
                if (ops.isEmpty() || prior(c, ops.peek())) {
                    ops.push(c);
                } else {
                    while (!ops.isEmpty() && !prior(c, ops.peek())) {
                        fetchAndCal(nums, ops);
                    }
                    ops.push(c);
                }
                i++;
            }
        }

        while(!ops.isEmpty()) {
            fetchAndCal(nums, ops);
        }

        return nums.pop();
    }

    public boolean prior(char a, char b) {
        if ((a == '*' || a == '/') && (b == '+' || b == '-')) {
            return true;
        }
        return false;
    }

    public int cal(char op, int num1, int num2) {
        switch(op) {
            case '+' : return num1 + num2;
            case '-' : return num1 - num2;
            case '*' : return num1 * num2;
            case '/' : return num1 / num2;
        }
        return -1;
    }

    public boolean isDigit(char c) {
        return c >= '0' && c <= '9';
    }

    public void fetchAndCal(Stack<Integer> nums, Stack<Character> ops) {
        int num2 = nums.pop();
        int num1 = nums.pop();
        char op = ops.pop();
        int res = cal(op, num1, num2);
        nums.push(res);
    }
}

2. 删除字符串中所有相邻重复项

链接：https://leetcode.cn/problems/remove-all-adjacent-duplicates-in-string

2.1 题目

给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 S 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

示例：

输入：“abbaca”
输出：“ca”
解释：
例如，在 “abbaca” 中，我们可以删除 “bb” 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 “aaca”，其中又只有 “aa” 可以执行重复项删除操作，所以最后的字符串为 “ca”。

2.2 题解

class Solution {
    public String removeDuplicates(String s) {
        Deque<Character> deque = new LinkedList<>();
        int n = 0;
        int num = s.length();
        while (n < num) {
            char c = s.charAt(n);
            if (deque.isEmpty() || deque.peekLast() != c) {
                deque.addLast(c);
            } else {
                deque.pollLast();
            }
            n++;
        }
        StringBuilder sb = new StringBuilder();
        while (!deque.isEmpty()) {
            sb.append(deque.pollFirst());
        }
        return sb.toString();
    }
}

3 栈的压入、弹出序列

3.1 题目

链接：https://leetcode.cn/problems/zhan-de-ya-ru-dan-chu-xu-lie-lcof

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。

示例 1：

输入：pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
输出：true
解释：我们可以按以下顺序执行：
push(1), push(2), push(3), push(4), pop() -> 4,
push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1
示例 2：

输入：pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
输出：false
解释：1 不能在 2 之前弹出。

3.2 题解

按照给定的入栈和出栈的元素进行操作，如果不能正常入栈和出栈，则序列错误

class Solution {
    public boolean validateStackSequences(int[] pushed, int[] popped) {
        Stack<Integer> stack = new Stack<>();
        int i = 0;
        int j = 0;
        int k = 0;
        while (k < pushed.length + popped.length) {
            k++;
            // 如果栈不为空并且出栈序列有元素，栈顶元素等于出栈序列的元素
            // 出栈
            if (!stack.isEmpty() && j < popped.length && stack.peek() == popped[j]) {
                stack.pop();
                j++;
                continue;
            }
            
            // 入栈
            if (i < pushed.length) {
                stack.push(pushed[i]);
                i++;
                continue;
            }
            return false;
        }
        return true;
    }
}

4 每日温度

链接：https://leetcode.cn/problems/daily-temperatures

4.1 题目

给定一个整数数组 temperatures ，表示每天的温度，返回一个数组 answer ，其中 answer[i] 是指对于第 i 天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用 0 来代替。

示例 1:

输入: temperatures = [73,74,75,71,69,72,76,73]
输出: [1,1,4,2,1,1,0,0]
示例 2:

输入: temperatures = [30,40,50,60]
输出: [1,1,1,0]
示例 3:

输入: temperatures = [30,60,90]
输出: [1,1,0]

4.2 题解

4.2.1 暴力解法（超出时间限制）

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        int n = temperatures.length;
        int[] result = new int[n];
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; j++) {
                if (temperatures[j] > temperatures[i]) {
                    result[i] = j - i;
                    break;
            }
        }
    }
    return result;
}
}

4.2.2单调栈

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        int n = temperatures.length;
        int result[] = new int[n];
        Stack<Integer> stack = new Stack<>();
        for (int i = 0; i < n; i++) {
            while (!stack.isEmpty() && temperatures[stack.peek()] < temperatures[i]) {
                int idx = stack.peek();
                result[idx] = i - idx;
                stack.pop();
            }
            stack.push(i);
        }
        return result;
    }
}

5 接雨水（hard）

链接：https://leetcode.cn/problems/trapping-rain-water

5.1 题目

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例 1：

输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。
示例 2：

输入：height = [4,2,0,3,2,5]
输出：9

5.2 题解

5.2.1 暴力解法

每个主子上的承载水量=min(左侧最高柱子lh,右侧最高柱子rh)-这个柱子高度h的总接水量=每个柱子之上的承载水量总和

class Solution {
    public int trap(int[] height) {
        int n = height.length;
        int result = 0;
        // 遍历每个柱子，找到左面最高的柱子和右面最高的柱子
        for (int i = 0; i < n - 1; ++i) {
            int lh = 0;
            for (int j = 0; j < i; j++) {
                if (height[j] > lh) {
                    lh = height[j];
                }
            }
            int rh = 0;
            for (int j = i + 1; j < n; j++) {
                if (height[j] > rh) {
                    rh = height[j];
                }
            }

            int carry = Math.min(lh, rh) - height[i];
            if (carry < 0) {
                carry = 0;
            }
            result += carry;
        }
        return result;
    }
}

5.2.2 前缀/后缀统计解法

利用空间换时间

创建两个数组，分别存储当前位置左侧最大高度和右侧最大高度

先循环填充两个数组

class Solution {
    public int trap(int[] height) {
        int n = height.length;
        // 前缀max
        int[] lmax = new int[n];
        int max = 0;
        for (int i = 0; i < n; ++i) {
            lmax[i] = Math.max(max, height[i]);
            max = lmax[i];
        }

        // 后缀max
        int[] rmax = new int[n];
        max = 0;
        for (int i = n - 1; i >= 0; --i) {
            rmax[i] = Math.max(max, height[i]);
            max = rmax[i];
        }

        int result = 0;
        for (int i = 0; i < n - 1; i++) {
            result += Math.min(lmax[i], rmax[i]) - height[i];
        }
        return result;
    }
}

5.2.3 单调栈

前面两种方法按照垂直计算，该方法水平计算，一层一层计算存水量

class Solution {
    public int trap(int[] height) {
        int n = height.length;
        int result = 0;
        Stack<Integer> stack = new Stack<>();
        for (int i = 0; i < n; i++) {
            if (stack.isEmpty()) {
                stack.push(i); // 存下标
                continue;
            }
            while (!stack.isEmpty()) {
                int top = stack.peek();
                if (height[top] >= height[i]) {
                    stack.push(i);
                    break;
                } else { // 找到凹槽了
                    top = stack.pop();
                    if (stack.isEmpty()) {
                        stack.push(i);
                        break;
                    }
                    int left = stack.peek();
                    int h = Math.min(height[left], height[i]) - height[top];
                    int w = i - left - 1;
                    result += h * w;
                }
            }
        }
        return result;
    }
}