【力扣一刷】代码随想录day10（栈和队列基础、232、 225）

已于 2024-03-16 21:53:10 修改
阅读量555 收藏 13
点赞数 24
分类专栏： 力扣一刷打卡日记 文章标签： java 算法 开发语言
于 2024-03-16 00:56:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46135891/article/details/136751043
版权

【队列和栈基础】

一、Java中的栈（先进后出，左边栈底，右边栈顶）

1、Stack类创建栈和使用栈

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        // 创建一个Stack对象
        Stack<String> stack = new Stack<>();

        // 添加元素到堆栈中
        stack.push("元素1");
        stack.push("元素2");
        stack.push("元素3");

        // 获取堆栈的大小
        int size = stack.size();
        System.out.println("堆栈的大小：" + size);

        // 检查堆栈是否为空
        boolean isEmpty = stack.isEmpty();
        System.out.println("堆栈是否为空：" + isEmpty);

        // 查看堆栈顶部的元素，但不移除它
        String topElement = stack.peek();
        System.out.println("堆栈顶部的元素：" + topElement);

        // 移除堆栈顶部的元素
        String poppedElement = stack.pop();
        System.out.println("移除的元素：" + poppedElement);

        // 再次查看堆栈顶部的元素
        topElement = stack.peek();
        System.out.println("堆栈顶部的元素：" + topElement);
        
        // 遍历堆栈中的元素
        System.out.println("遍历堆栈中的元素：");
        while (!stack.isEmpty()) {
            String element = stack.pop();
            System.out.println(element);
        }
    }
}

上面代码的输出：

堆栈的大小：3
堆栈是否为空：false
堆栈顶部的元素：元素3
移除的元素：元素3
堆栈顶部的元素：元素2
遍历堆栈中的元素：
元素2
元素1

2、用LinkedList实现栈

import java.util.LinkedList;

public class MyStack {
    private LinkedList<String> stack;

    public MyStack() {
        stack = new LinkedList<>();
    }

    public void push(String element) {
        stack.addLast(element);
    }

    public String pop() {
        return stack.removeLast();
    }

    public String peek() {
        return stack.getLast();
    }

    public int size() {
        return stack.size();
    }

    public boolean isEmpty() {
        return stack.isEmpty();
    }
}

注意：Stack类是继承自Vector类的经典栈数据结构，而LinkedList是一个实现了List接口的双向链表。官方建议使用LinkedList来替代Stack类实现栈的功能，因为LinkedList的性能更好。

二、队列（先进先出，左边队头，右边队尾）

import java.util.LinkedList;
import java.util.Queue;

public class Main {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();

        // 向队尾插入元素
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);

        // 查看队首元素
        System.out.println("队首元素：" + queue.peek());

        // 出队
        int removedElement = queue.poll();
        System.out.println("出队元素：" + removedElement);

        // 再次查看队首元素
        System.out.println("队首元素：" + queue.peek());
    }
}

上面代码的输出：

队首元素：1
出队元素：1
队首元素：2

注意：

1、Queue接口定义了一些用于添加、删除和检索元素的方法，如 offer() 、 poll() 、peek()。

2、LinkedList是Java集合框架中的一个类，它实现了List接口，并且也实现了Queue接口。由于LinkedList是一个双向链表，它具有在两端进行高效插入和删除操作的特性，非常适合实现队列的功能。因此，可以利用多态的写法定义Queue对象，如：Queue<Integer> queue = new LinkedList<>();。

3、通过LinkedList实现的Queue具有队列的特性，可以使用 offer() 方法向队列尾部添加元素，使用 poll() 方法从队列头部移除并返回元素，使用 peek() 方法获取队列头部的元素但不移除它。

【232.用栈实现队列】

class MyQueue {
    private Stack<Integer> stackIn;  // 负责进队
    private Stack<Integer> stackOut;  // 负责出队

    public MyQueue() {
        this.stackIn = new Stack<>();
        this.stackOut = new Stack<>();
    }
    
    public void push(int x) {
        stackIn.push(x);
    }
    
    public int pop() {
        // 注意：只有stackOut空的时候倒过去才符合队列的顺序
        if (stackOut.isEmpty()){
            pour();
        }
        return stackOut.pop();
    }
    
    public int peek() {
        if (stackOut.isEmpty()){
            pour();
        }
        return stackOut.peek();
    }
    
    public boolean empty() {
        return stackIn.isEmpty() && stackOut.isEmpty();
    }

    private void pour(){
        while(!stackIn.isEmpty()){
            stackOut.push(stackIn.pop());
        }
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = new MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * boolean param_4 = obj.empty();
 */

时间复杂度: O(n)，pop()和peak()都要用pour()，都是O(n), empty()和push()都是O(1)

空间复杂度: O(n)，两个栈 stackIn 和 stackOut都为 O(n)

【225. 用队列实现栈】

方法一   用两个队列实现栈，push简单，pop难

push：

pop：

class MyStack {
    Queue<Integer> queue1;
    Queue<Integer> queue2;
    
    public MyStack() {
        queue1 = new LinkedList<>(); // 负责进栈、存储栈元素
        queue2 = new LinkedList<>();  // 辅助出栈
    }
    
    public void push(int x) {
        queue1.offer(x);
    }
    
    public int pop() {
        int popElement = 0;  // 必须初始化否则会报错，保证在栈非空情况下调用pop的前提下，初始值可以为任意值
        // 1、将除了栈顶元素之外的元素压进queue2，获取栈顶元素
        while(!queue1.isEmpty()){
            popElement = queue1.poll();
            // 如果queue1弹出元素后就空了，证明弹出的元素是队尾元素，不需要再进queue2队
            if (!queue1.isEmpty()){
                queue2.offer(popElement);
            }
        }

        // 2、将queue1和queue2交换，让queue1始终负责进栈
        Queue<Integer> queue = queue1;
        queue1 = queue2;
        queue2 = queue;

        return popElement;
    }
    
    public int top() {
        // 利用出栈获取队尾元素
        int q = pop();
        // 再进栈恢复原始栈
        push(q);
        return q;
    }
    
    public boolean empty() {
        return queue1.isEmpty(); // queue1始终用于存储栈元素，判断queue1是否空即可
    }
}

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */

时间复杂度: O(n)，pop()和top()都是O(n), empty()和push()都是O(1)

空间复杂度: O(n)，使用的三个队列都为 O(n)

方法二   用两个队列实现栈，push难，pop简单

push：

pop：

class MyStack {
    Queue<Integer> queue1;
    Queue<Integer> queue2;

    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }
    
    public void push(int x) {
        // 1、先将x放入queue2暂存
        queue2.offer(x);
        // 2、再将queue1的元素压进queue2
        while(!queue1.isEmpty()){
            queue2.offer(queue1.poll());
        }
        // 3、将queue2和queue1互换
        Queue<Integer> queue = queue1;
        queue1 = queue2;
        queue2 = queue;
    }
    
    public int pop() {
        return queue1.poll();
    }
    
    public int top() {
        return queue1.peek();
    }
    
    public boolean empty() {
        return queue1.isEmpty();
    }
}

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */

时间复杂度: O(n)，只有push()是O(n)，其余都是O(1)

空间复杂度: O(n)，使用的三个队列都为 O(n)

方法三  优化版，只用一个队列实现（对应方法一的优化）

class MyStack {
    Queue<Integer> queue;
    int size;

    public MyStack() {
        queue = new LinkedList<>();
        size = 0;
    }
    
    public void push(int x) {
        queue.offer(x);
        size++;
    }
    
    public int pop() {
        // 1、除了栈顶以外的元素循环出队进队
        for (int i = 0; i < size - 1; i++){
            queue.offer(queue.poll());
        }

        // 2、弹出栈顶元素
        size--;
        return queue.poll();
    }
    
    public int top() {
        int q = pop();
        push(q);
        return q;
    }
    
    public boolean empty() {
        return queue.isEmpty();
    }
}

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */

时间复杂度: O(n)，pop()和top()都是O(n), empty()和push()都是O(1)

空间复杂度: O(n)，使用一个队列为 O(n)

方法四  优化版，只用一个队列实现（对应方法二的优化）

class MyStack {
    Queue<Integer> queue;
    int size;

    public MyStack() {
        queue = new LinkedList<>();
        size = 0;
    }
    
    public void push(int x) {
        // 1、先将x压进栈
        queue.offer(x);
        size++;

        // 2、再调整顺序使x为栈顶元素
        for (int i = 0; i < size - 1; i++){
            queue.offer(queue.poll());
        }
    }
    
    public int pop() {
        size--;
        return queue.poll();
    }
    
    public int top() {
        return queue.peek();
    }
    
    public boolean empty() {
        return queue.isEmpty();
    }
}

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */

时间复杂度: O(n)，只有push()是O(n)，其余都是O(1)

空间复杂度: O(n)，使用一个队列为 O(n)

weixin_46135891
关注
  • 24
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Python算法题源代码-LeetCode(力扣)-二叉树中的最大路径和
02-21
力扣热题Python源代码 题目：124. 二叉树中的最大路径和 二叉树中的 路径 被定义为一条节点序列，序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不...
【代码随想录】Day 10 栈和队列（栈实现队列、队列实现栈）
weixin_43785314的博客
07-21 36
HP STL 其他版本的C++ STL，一般是以HP STL为蓝本实现出来的，HP STL是C++ STL的第一个实现版本，而且开放源代码。构建一个输入栈和一个输出栈，队列输入时push进输入栈就行，队列输出时要将输入栈里的元素反向存到输出栈中，然后pop输出栈的元素。栈是用底层容器来实现的，所以栈不是容器，而是容器适配器，可以控制使用哪种容器来实现栈的功能。empty()，判断队列是否为空，为空返回true，即1，非空返回false，即0。pop()，删除队列中第一个元素，返回值为void。
代码随想录算法训练营day10｜理论基础，232.用栈实现队列，225. 用队列实现栈
weixin_52121600的博客
11-04 115
栈与队列day1
代码随想录 Day10 栈与队列 LeetCode T239 滑动窗口的最大值 T347 前K个高频元素
qiuqiushuibx的博客
10-04 189
首先创建一个map,key用来放置元素,value用来存放出现频率,这题我们就用到了优先级队列了,因为我们想用低于快排的时间复杂度解决问题,我们就只能使用大顶堆或小顶堆的数据结构,维护一个k个元素的堆来解决问题,最后将前k个元素依次pop出来即可.(这里为了简化代码使用了lambda表达式)首先创建单调队列,先将前k个元素传入单调队列,获取其最大值,对k到数组结束的元素进行以下处理,先poll前k个元素,加入新的元素,比较得到最大值,最后返回最大值数组即可.
【力扣一刷】代码随想录day13（239、347、 栈与队列总结）
weixin_46135891的博客
03-17 284
思路：利用双端队列实现，队列只存可能为最大值的值，队头始终是最大值1、设定双端队列的规则队头始终是队列的最大值，队列始终是降序排序的。2、利用push(int x)方法维护队列规则需要先将队列中x前面比x小的值弹出，再将x压入队列。3、利用for循环遍历数组中的每个元素当还没遍历到k个值时，只需要将遍历到的元素压入队列当遍历到第k个值时，还要记录当前滑动窗口的最大值，弹出窗口最左边的值当前窗口最左边的值很可能在【将当前遍历元素push进队列】的时候就已经弹出（维护规则所需），因此要加判断条件。
代码随想录算法训练营Day10 232. 用栈实现队列 225. 用队列实现栈
Harper926的博客
06-04 53
232. 用栈实现队列232. 用栈实现队列。
js代码-力扣53-给定一个数组，找到具有最大和的连续子数组
07-16
js代码-力扣53-给定一个数组，找到具有最大和的连续子数组
Python算法题源代码-LeetCode(力扣)-在排序数组中查找元素的第一个和最后一个位置
03-09
力扣热题Python源代码 题目34. 在排序数组中查找元素的第一个和最后一个位置 给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。 如果数组中不...
华为OD和力扣刷题记录库
05-10
当然你可以先写一遍 JavaScript，再尝试着转换为 TypeScript。 为什么呢？以前是个人的一些见解 TypeScript 能帮助 JavaScript 开发者去适应静态数据类型的检查，避免数据类型使用不当导致程序出错 TypeScript ...
代码随想录算法训练营Day10 | 232.用栈实现队列225. 用队列实现栈
m0_66462858的博客
10-02 86
1. **两个栈**：在两个栈模拟队列中，通常会有两个栈，一个用于入队列操作（push），另一个用于出队列操作（pop 和 peek）。- 如果栈不为空，通过循环将队列中除了最后一个元素外的所有元素出队列并入队列，这个操作使得原本在队列头部的元素移到了队列尾部。- 如果栈不为空，通过循环将队列中除了最后一个元素外的所有元素出队列并入队列，这个操作使得原本在队列头部的元素移到了队列尾部。- 然后，将队列头部的元素（栈顶元素）暂时存储在 `temp` 变量中，再将 `temp` 入队列，以恢复原本的队列状态。
代码随想录day10|232. 用栈实现队列225. 用队列实现栈
weixin_56718399的博客
11-04 89
力扣打卡
代码随想录 Day8 栈(FILO)与队列(FIFO) LeetCode T232 用栈实现队列 LeetCodeT225 用队列实现栈
qiuqiushuibx的博客
10-02 160
栈和队列都是大家不陌生的数据结构,我们之前的栈和队列一般是用数组或链表来实现的 ,这里我们给出实现方式,用于帮助更好的理解.
代码随想录DAY10| 232. 用栈实现队列 225. 用队列实现栈
m0_62867573的博客
10-21 130
力扣练习
【力扣一刷】代码随想录day11（20、1047、 150）
weixin_46135891的博客
03-16 975
Java中的Deque接口。
jar包增量更新分析
junlaiyan的专栏
05-16 245
借助jdeps分析出jar包的增量文件
java实现拼图小游戏
monkey108的博客
05-16 610
本文主要提供用java实现的拼图小游戏源代码。
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 896
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
命令执行漏洞（二）
XLbb的博客
05-15 896
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
java数据结构与算法(验证二叉搜索树)
最新发布
磐门的博客
05-17 242
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
力扣山的回文子串解析 代码随想录
07-27
这段代码的思路是，首先初始化长度为1和2的回文子串，然后从字符串末尾开始遍历，逐个判断子串是否为回文。如果当前子串是回文，则计数加1。 该解法的时间复杂度为O(n^2)，空间复杂度为O(n^2)，其中n为字符串的长度...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值