【算法-栈与队列】

Ted0067

已于 2023-08-24 04:05:36 修改

阅读量38

点赞数

文章标签：算法 java

于 2023-08-23 01:20:31 首次发布

本文链接：https://blog.csdn.net/Ted0067/article/details/132402480

版权

基础

队列是先进先出，栈是先进后出
栈与队列理论基础

232. 用栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false

思路:

使用两个栈来存储数据(入栈, 出栈), 在队列新增数据时入栈压入数据, 队列弹出数据时, 将入栈的数据依次压入出栈中, 则再在出栈中弹出数据, 则可实现先进先出

代码实现:

class MyQueue {

    private final Stack<Integer> stackIn;
    private final Stack<Integer> stackOut;

    /**
     * 初始化两个栈
     */
    public MyQueue() {
        stackIn = new Stack<>();
        stackOut = new Stack<>();
    }

    /**
     * 存入一个数据
     */
    public void push(int x) {
        stackIn.push(x);
    }

    /**
     * 弹出队列第一个值
     */
    public int pop() {
        dumpStackIn();
        return stackOut.pop();
    }

    /**
     * 获取队列第一个值
     */
    public int peek() {
        dumpStackIn();
        return stackOut.peek();
    }

    /**
     * 是否为空: 进栈和出栈同时为空
     */
    public boolean empty() {
        return stackIn.isEmpty() && stackOut.isEmpty();
    }

    /**
     * 将入栈的数据移动到出栈中
     */
    private void dumpStackIn() {
        if (!stackOut.isEmpty()) {
            return;
        }
        // 出栈全部弹出 再从入栈中迁移数据
        while (!stackIn.isEmpty()) {
            stackOut.push(stackIn.pop());
        }
    }
}

225. 用队列实现栈

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

思路:

使用两个队列模拟先进后出, 在添加元素时, 将元素放入缓存队列, 则新元素在缓存队列弹出位的第一位, 而后再将队列中其他元素依次加入队列, 则新加入元素永远在弹出第一位, 其他元素按压入顺序依次在后面.

代码实现:

class MyStack {

    // 和栈中保持一样元素的队列
    private Queue<Integer> queue;
    // 缓存队列
    private Queue<Integer> buffer;

    /**
     * 初始化
     */
    public MyStack() {
        queue = new LinkedList<>();
        buffer = new LinkedList<>();
    }

    /**
     * 入栈
     */
    public void push(int x) {
        // 添加元素到队列
        buffer.offer(x);
        while (!queue.isEmpty()) {
            buffer.offer(queue.poll());
        }
        // 队列和缓存互换
        Queue<Integer> temp;
        temp = queue;
        queue = buffer;
        buffer = temp;
    }

    public int pop() {
        return queue.poll();
    }

    public int top() {
        return queue.peek();
    }

    public boolean empty() {
        return queue.isEmpty();
    }
}

20. 有效的括号

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。

示例 1：

输入：s = "()"
输出：true

示例 2：

输入：s = "()[]{}"
输出：true

示例 3：

输入：s = "(]"
输出：false

思路: 栈->先进后出

遍历字符串数组, 使用栈存储, 若元素为左括号, 则将对应的右括号压入栈中.
当新元素为右括号时, 则弹出栈, 若栈为空或弹出值与输入右括号不相等, 则说明该字符串不符合要求, 即括号不闭合.
若字符串数组全部遍历后, 栈内仍有元素未被消费, 亦说明该字符串不符合要求, 即括号不闭合.

代码实现:

public boolean isValid(String s) {
    Stack<Character> stack = new Stack<>();
    char[] charArray = s.toCharArray();
    for (char c : charArray) {
        switch (c) {
            case '(':
                stack.push(')');
                break;
            case '{':
                stack.push('}');
                break;
            case '[':
                stack.push(']');
                break;
            default:
                if (stack.isEmpty() || stack.pop() != c) {
                    return false;
                }
        }
    }
    return stack.isEmpty();
}

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

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

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

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

示例：

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

思路:

使用栈做缓存容器, 遍历字符串数组, 若当前字符与前一个(缓存在栈中)相同, 则当前字符不入栈, 且将前一个字符弹出, 若不相等, 则当前字符入栈.

代码实现:

public String removeDuplicates(String s) {
    Stack<Character> stack = new Stack<>();
    stack.push(s.charAt(0));
    char c;
    for (int i = 1; i < s.length(); i++) {
        c = s.charAt(i);
        // 若后面的值 与前面的值不匹配 则 数据入栈
        if (stack.isEmpty() || c != stack.peek()) {
            stack.push(c);
        } else {
            stack.pop();
        }
    }
    // 将剩余字符串拼接返回
    String res = "";
    while (!stack.isEmpty()) {
        res = stack.pop() + res;
    }
    return res;
}

150. 逆波兰表达式求值

给你一个字符串数组 tokens ，表示一个根据逆波兰表示法表示的算术表达式。

请你计算该表达式。返回一个表示表达式值的整数。

注意：
有效的算符为 '+'、'-'、'*' 和 '/' 。每个操作数（运算对象）都可以是一个整数或者另一个表达式。两个整数之间的除法总是向零截断。表达式中不含除零运算。输入是一个根据逆波兰表示法表示的算术表达式。答案及所有中间计算结果可以用 32 位整数表示。

示例 1：

输入：tokens = ["2","1","+","3","*"]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

示例 2：

输入：tokens = ["4","13","5","/","+"]
输出：6
解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6

示例 3：

输入：tokens = ["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

思路:

由题可知提供的数组tokens一定可以解析为计算式
则可知, 每遇到一个数字, 则存入缓存栈中.
则可知, 每遇到一个运算符号, 则将到栈内弹出两个数字做运算.
返回最后一个运算结果.

代码实现:

public int evalRPN(String[] tokens) {
    Stack<String> stack = new Stack<>();
    for (String token : tokens) {
        switch (token) {
            case "+":
                stack.push(String.valueOf(Integer.parseInt(stack.pop()) + Integer.parseInt(stack.pop())));
                break;
            case "-":
                int minuend = Integer.parseInt(stack.pop());
                int subtrahend = Integer.parseInt(stack.pop());
                stack.push(String.valueOf(subtrahend - minuend));
                break;
            case "*":
                stack.push(String.valueOf(Integer.parseInt(stack.pop()) * Integer.parseInt(stack.pop())));
                break;
            case "/":
                int dividend = Integer.parseInt(stack.pop());
                int divisor = Integer.parseInt(stack.pop());
                stack.push(String.valueOf(divisor / dividend));
                break;
            default:
                stack.push(token);
        }
    }
    return Integer.parseInt(stack.pop());
}

239. 滑动窗口最大值

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回滑动窗口中的最大值。

示例 1：

输入：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

示例 2：

输入：nums = [1], k = 1
输出：[1]

代码实现:

347.前 K 个高频元素

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按任意顺序返回答案。

示例 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

示例 2:

输入: nums = [1], k = 1
输出: [1]

代码实现:

Ted0067

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫