数据结构与算法-02栈和队列-03

原创 已于 2024-11-21 15:56:50 修改 · 368 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #数据结构 #java #leetcode #c++

于 2024-11-21 15:40:48 首次发布

力扣问题

图书整理II

问题

[力扣125] LCR 125. 图书整理 II - 力扣（LeetCode）

问题描述

读者来到图书馆排队借还书，图书管理员使用两个书车来完成整理借还书的任务。书车中的书从下往上叠加存放，图书管理员每次只能拿取书车顶部的书。排队的读者会有两种操作：

  • push(bookID)：把借阅的书籍还到图书馆。
  • pop()：从图书馆中借出书籍。

为了保持图书的顺序，图书管理员每次取出供读者借阅的书籍是 最早 归还到图书馆的书籍。你需要返回 每次读者借出书的值 。

如果没有归还的书可以取出，返回 -1 。

示例 1：

输入：
["BookQueue", "push", "push", "pop"]
[[], [1], [2], []]
输出：[null,null,null,1]
解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.pop(); // return 1, queue is [2]

解决方案

图书管理员每次取出供读者借阅的书籍是 最早 归还到图书馆的书籍, 类似于队列问题，由于队列可借可还，可以考虑循环队列。

image-20241116141608883

参考实现

class CQueue {
    private Deque<Integer> q;
    public CQueue() {
        q = new ArrayDeque<>();
    }
    
    public void appendTail(int value) {
        q.offer(value);
    }
    
    public int deleteHead() {
        if(!q.isEmpty()){
             return q.poll();
        }else{
            return -1;
        }
    
    }
}


class CQueue {
    private int[] nums = new int[5000];
    private int head;
    private int tail;

    public CQueue() {

    }

    public void appendTail(int value) {
        if ((tail + 1) % nums.length == head) { // 满队列
            return;
        }
        nums[tail] = value;
        tail = (tail + 1) % nums.length;
    }

    public int deleteHead() {
        if (head == tail)
            return -1; // 空队列
        int val = nums[head];
        head = (head + 1) % nums.length;
        return val;
    }
}

用栈实现队列

问题

232. 用栈实现队列 - 力扣（LeetCode）

问题描述

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

实现 MyQueue 类：

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

说明：

  • 你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
  • 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

示例 1：

输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

提示：

  • 1 <= x <= 9
  • 最多调用 100 次 push、pop、peek 和 empty
  • 假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）

进阶：

  • 你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。

解决方案

参考实现

class MyQueue {
    private Stack<Integer> s1;  //压入 
    private Stack<Integer> s2;  //出

    public MyQueue() {
        s1 = new Stack<>();
        s2 = new Stack<>();
    }
    
    public void push(int x) {
        s1.push(x);
    }
    
    public int pop() {
        if(s2.isEmpty()){
            while(!s1.isEmpty()){
                s2.push(s1.pop());
            }
        }
        return s2.pop();
    }
    
    public int peek() {
        if(s2.isEmpty()){
            while(!s1.isEmpty()){
                s2.push(s1.pop());
            }
        }
        return s2.peek();
    }
    
    public boolean empty() {
        return s1.isEmpty() && s2.isEmpty();
    }
}

用队列实现栈

题目

[ 力扣225] 225. 用队列实现栈 - 力扣（LeetCode）

题目描述

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

实现 MyStack 类：

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

注意：

  • 你只能使用队列的标准操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
  • 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：

输入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

解决方案

在这里插入图片描述

参考实现

有效的括号

问题

[力扣20] 20. 有效的括号 - 力扣（LeetCode）

题目描述

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

有效字符串需满足：

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

示例 1：

输入：s = "()"

输出：true

示例 2：

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

输出：true

示例 3：

输入：s = "(]"

输出：false

示例 4：

输入：s = "([])"

输出：true

解决方案(一)

  • 遍历字符是（ ， { ， [

    image-20241115194959091 image-20241115195038109

  • 遍历字符是 ) } ]

    image-20241115195126035

解决方案(二)

使用Map存储成对的括号 。

image-20241115201108097

计算器

问题

[力扣面试题16.26] 面试题 16.26. 计算器 - 力扣（LeetCode）

问题描述

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

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

示例 1:

输入: "3+2*2"
输出: 7

示例 2:

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

示例 3:

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

解决方案

image-20241115191733505

参考实现

class Solution {
    public int calculate(String s) {
        //定义队列记录数值
        Deque<Integer> stackNums = new ArrayDeque<>();
         //去掉空格，分解数字和符号
        s = s.replaceAll(" ", "");
        String[] split = s.split("[+*/-]"); //存储数值
        String[] cs = ("+"+s).split("[0-9]+"); //存储符号

        if(cs.length == 0) return Integer.valueOf(split[0]); //如果只有一个数字则直接返回

        int index = 0; //记录数值数组的索引
        for( String opt : cs){
            int num = Integer.valueOf(split[index++]);//将数值字符串转换为整数
            switch (opt){
                case "+":  //如果为+号直接存储
                    stackNums.push(num);
                    break;
                case "-": //如果为-号理解为正数的相反数
                    stackNums.push(-1*num);
                    break;
                case "*": //乘除法先运算
                    stackNums.push(stackNums.poll() * num);
                    break;
                case "/":
                    stackNums.push(stackNums.poll() /num);
            }
        }

        //计算栈中的数据求和(乘除已经计算完成)
        int result = 0;
        while (!stackNums.isEmpty()) {
            result += stackNums.poll();
        }
        return result;
    }
}

棒球比赛

题目

[力扣682] 682. 棒球比赛 - 力扣（LeetCode）

题目描述

你现在是一场采用特殊赛制棒球比赛的记录员。这场比赛由若干回合组成，过去几回合的得分可能会影响以后几回合的得分。

比赛开始时，记录是空白的。你会得到一个记录操作的字符串列表 ops，其中 ops[i] 是你需要记录的第 i 项操作，ops 遵循下述规则：

  1. 整数 x - 表示本回合新获得分数 x
  2. "+" - 表示本回合新获得的得分是前两次得分的总和。题目数据保证记录此操作时前面总是存在两个有效的分数。
  3. "D" - 表示本回合新获得的得分是前一次得分的两倍。题目数据保证记录此操作时前面总是存在一个有效的分数。
  4. "C" - 表示前一次得分无效，将其从记录中移除。题目数据保证记录此操作时前面总是存在一个有效的分数。

请你返回记录中所有得分的总和。

示例 1：

输入：ops = ["5","2","C","D","+"]
输出：30
解释：
"5" - 记录加 5 ，记录现在是 [5]
"2" - 记录加 2 ，记录现在是 [5, 2]
"C" - 使前一次得分的记录无效并将其移除，记录现在是 [5].
"D" - 记录加 2 * 5 = 10 ，记录现在是 [5, 10].
"+" - 记录加 5 + 10 = 15 ，记录现在是 [5, 10, 15].
所有得分的总和 5 + 10 + 15 = 30

示例 2：

输入：ops = ["5","-2","4","C","D","9","+","+"]
输出：27
解释：
"5" - 记录加 5 ，记录现在是 [5]
"-2" - 记录加 -2 ，记录现在是 [5, -2]
"4" - 记录加 4 ，记录现在是 [5, -2, 4]
"C" - 使前一次得分的记录无效并将其移除，记录现在是 [5, -2]
"D" - 记录加 2 * -2 = -4 ，记录现在是 [5, -2, -4]
"9" - 记录加 9 ，记录现在是 [5, -2, -4, 9]
"+" - 记录加 -4 + 9 = 5 ，记录现在是 [5, -2, -4, 9, 5]
"+" - 记录加 9 + 5 = 14 ，记录现在是 [5, -2, -4, 9, 5, 14]
所有得分的总和 5 + -2 + -4 + 9 + 5 + 14 = 27

示例 3：

输入：ops = ["1"]
输出：1

解决方案(一)

使用栈记录 C， D， +

image-20241115210012674

image-20241115210030671

image-20241115210042810

解决方案(二)

构建另一个数组存储数值，index记录数组的位置。

  • 如果为D将前一个数nums[index-1]*2
  • 如果为C回退2个位置index-=2
  • 如果为+号，前两个数相加: nums[index-1]+nums[index-2]
  • 如果为数值： nums[index]
  • 每扫描一次index++

image-20240408150019425

int[] nums = new int[operations.length];
int index = 0;
for (String str : operations) {
    if ("+".equals(str)) {
        nums[index] = nums[index - 1] + nums[index - 2];
    } else if ("C".equals(str)) {
        index -= 2;
    } else if ("D".equals(str)) {
        nums[index] = nums[index - 1] * 2;
    } else {
        nums[index] = Integer.parseInt(str);
    }
    index++;
}
int s = 0;
for (int i = 0; i < index; i++) {
    s += nums[i];
}

return s;

最小栈

题目

[力扣155] 155. 最小栈 - 力扣（LeetCode）

题目描述

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

实现 MinStack 类:

  • MinStack() 初始化堆栈对象。
  • void push(int val) 将元素val推入堆栈。
  • void pop() 删除堆栈顶部的元素。
  • int top() 获取堆栈顶部的元素。
  • int getMin() 获取堆栈中的最小元素。

示例 1:

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

解决方案

push操作

image-20241121133320677

pop操作

![image-20241121133711085](https://typero-imgas.oss-cn-chengdu.aliyuncs.com/img/202411211337181.png

参考实现

class MinStack {

    Stack<Integer> normal;
    Stack<Integer> min;

    public MinStack() {
        normal = new Stack<>();
        min = new Stack<>();
    }

    public void push(int val) {
        normal.push(val);
        if (min.isEmpty() || min.peek() >= val) {
            min.push(val);
        }
    }

    public void pop() {
        int top = normal.peek();
        int mTop = min.peek();

        if (top == mTop) {
            min.pop();
        }
        normal.pop();
    }

    public int top() {
        return normal.peek();

    }

    public int getMin() {
        return min.peek();
        
    }
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值