栈和队列(栈和队列的那些事)

最新推荐文章于 2025-09-03 23:14:03 发布
原创 最新推荐文章于 2025-09-03 23:14:03 发布 · 145 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #算法 #队列

本文详细介绍了栈和队列的概念，以及它们在Java中的实现。通过实例展示了如何使用Stack和LinkedList创建栈和队列，并提供了手动实现泛型版本的栈和队列的代码。此外，还探讨了如何利用栈和队列解决常见面试问题，如用队列实现栈和用栈实现队列。这些内容有助于深入理解数据结构及其实际运用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.栈

1.1概念

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
原理图：
在这里插入图片描述

1.2java中的栈(Stack)

常用的方法：
在这里插入图片描述

1.3通过代码来感受一下


import java.util.Stack;

public class Test0530 {
    public static void main(String[] args) {
        Stack<Integer> stack=new Stack<>();
        System.out.println("入栈元素1");
        stack.push(1);
        System.out.println("查看栈顶元素"+stack.peek());
        System.out.println("出栈");
        stack.pop();
        System.out.println("看栈是否为空"+stack.empty());

    }
}

运行结果：
在这里插入图片描述

2.手动实现一个自己的栈(MyStack)

手动实现一个泛型版本的栈，可以用存储任意类型的数据：


public class MyStack<T> {
    private T[] arr=null;
    private int size;
    private int capacity=5;

    public MyStack() {
        arr= (T[]) new Object[capacity];
        this.size=0;
    }
    //入栈
    public void push(T var){
        if(size==capacity){ //判断栈是否满了
            //栈满了就扩容
           T[] newarr= (T[]) new Object[2*capacity];
            for(int i=0;i<size;i++){
                newarr[i]=arr[i];
            }
            arr=newarr;
            arr[size++]=var;
            return;
        }
        arr[size++]=var;
        return;
    }
    //出栈
    public void pop(){
        if(empty()){ //空栈
            return;
        }
        size--;
        return;

    }
    //查看栈顶元素
    public T peek(){
        if(empty()){
            return null;
        }
        return (T)arr[size-1];

    }
    //判断栈是否为空
    public boolean empty(){
        if (size==0){
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        MyStack<Integer> myStack=new MyStack<>();
        System.out.println(myStack.empty());
        myStack.push(1); //入栈
        myStack.push(2);
        myStack.push(3);
        myStack.push(4);
        myStack.push(5);
        myStack.push(6); //触发扩容
        myStack.pop();
        myStack.pop();
        Integer result = myStack.peek();
        System.out.println(result);
        System.out.println(myStack.empty());

        System.out.println("============");
        MyStack<String> myStack1=new MyStack<>();
        System.out.println(myStack1.empty());
        myStack1.push("C++");
        myStack1.push("java");
        myStack1.push("Go");
        System.out.println(myStack1.peek());
    }
}

运行结果：
在这里插入图片描述

3.队列

3.1概念

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)。
原理图：
在这里插入图片描述

3.2java中队列(Queue)

常用的方法：
在这里插入图片描述

3.3通过代码来感受一下


import java.util.LinkedList;
import java.util.Queue;
public class Test0530 {
    public static void main(String[] args) {
        Queue<Integer> queue=new LinkedList<>();
        queue.add(1);
        queue.offer(2);

        System.out.println(queue.element());
        System.out.println(queue.peek());
        queue.poll();
        queue.remove();

        System.out.println(queue.isEmpty());

    }
}

运行结果：
在这里插入图片描述

4.手动实现一个自己的队列( MyQueue)

手动实现一个泛型版本的队列，可以用存储任意类型的数据：


class MyExciption extends RuntimeException{
    public MyExciption(String msg) {
        super(msg);
    }
}

class Node<T>{
    T var;
    Node<T> pre;
    Node<T> next;

    public Node(T var) {
        this.var = var;
    }

    @Override
    public String toString() {
        return "Node{" +
                "var=" + var +
                '}';
    }
}

public class MyQueue<T> {
    private Node<T> head;
    private Node<T> tail;
    private int size;

    public MyQueue() {
        this.head = null;
        this.tail = null;
        this.size = 0;
    }
    //入队列  1  2   3
    public void offer(T var){
        Node<T> newNode=new Node<>(var);
        if(head==null){
            head=newNode;
            tail=newNode;
            size++;
            return;
        }
        //一般情况 1 2 3
        tail.next=newNode;
        newNode.pre=tail;
        tail=newNode;
        size++;
        return;

    }
    //入队列
    public void add(T var){
        Node<T> newNode=new Node<>(var);
        if(head==null){
            head=newNode;
            tail=newNode;
            size++;
            return;
        }
        //一般情况 1 2 3
        tail.next=newNode;
        newNode.pre=tail;
        tail=newNode;
        size++;
        return;

    }
    //出队列
    public void poll(){
        if(head==null){
            return ;
        }
        if(head.next==null){
            head=null;
            tail=null;
            size--;
            return;
        }
        //一般情况 1   2   3
        Node<T> curNode=head;
        Node<T> nextNode=curNode.next;
        nextNode.pre=null;
        head=nextNode;
        size--;
        return;

    }
    //出队列
    public void remove(){
        if(head==null){
            throw new MyExciption("位置非法！！！");
        }
        if(head.next==null){
            head=null;
            tail=null;
            size--;
            return;
        }
        //一般情况 1  2  3
        Node<T> curNode=head;
        Node<T> nextNode=curNode.next;
        nextNode.pre=null;
        head=nextNode;
        size--;
        return;

    }
    //判断是否为空队列
    public boolean isEmpty(){
        return size<=0;

    }
    //取队首元素
    public T peek(){
        if(head==null){
            return null;
        }
        return (T)head;
    }
    //取队首元素
    public T element(){
        if(head==null){
            throw new MyExciption("空指针异常！！！");
        }
        return (T)head;
    }

    public static void main(String[] args) {
        MyQueue<Integer> myQueue=new MyQueue<>();
        myQueue.add(1);
        myQueue.add(2);
        myQueue.offer(3);
        System.out.println(myQueue.peek());
        myQueue.poll();
        System.out.println(myQueue.element());
        System.out.println(myQueue.isEmpty());

    }
}

5.栈和队列常见的笔试题

1:用队列实现栈==>https://leetcode-cn.com/problems/implement-stack-using-queues/


//用两个队列实现一个栈

class MyStack {

    private Queue<Integer> A = new LinkedList<>();
    private Queue<Integer> B = new LinkedList<>();

    /** Initialize your data structure here. */
    public MyStack() {

    }

    /** Push element x onto stack. */
    public void push(int x) {
        // 入栈的时候, 就直接往 A 中插入
        A.offer(x);
    }

    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        // 出栈的时候, 把 A 中的元素往 B 中倒腾. 当 A 中只剩一个元素的时候,
        // 最后这个元素就是被删除的元素
        if (A.isEmpty() && B.isEmpty()) {
            // 针对空栈的判定. 但是人家给的方法不是 Integer, 没法返回 null, 只能随便返回个值了
            // 在线 OJ 的代码咱们不要抛出异常!!!
            return 0;
        }
        while (A.size() > 1) {
            int tmp = A.poll();
            B.offer(tmp);
        }
        // 当上面的循环结束, 此时 A 中就只剩一个元素了.
        // 把这个最后的元素就作为出栈的结果即可.
        int ret = A.poll();
        // 最终完成操作之后, 要交换 A 和 B 的身份. 保证下次入栈的时候, 还是往 A 中插入.
        swapAB();
        return ret;
    }

    private void swapAB() {
        Queue<Integer> tmp = A;
        A = B;
        B = tmp;
    }

    /** Get the top element. */
    public int top() {
        // 取栈顶元素和出栈类似. 唯一的区别就是, 出栈操作是把 A 的最后一个元素给删了.
        // 取栈顶元素操作是把 A 的最后一个元素还要再塞回到 B 中.
        // 出栈的时候, 把 A 中的元素往 B 中倒腾. 当 A 中只剩一个元素的时候,
        // 最后这个元素就是被删除的元素
        if (A.isEmpty() && B.isEmpty()) {
            // 针对空栈的判定. 但是人家给的方法不是 Integer, 没法返回 null, 只能随便返回个值了
            // 在线 OJ 的代码咱们不要抛出异常!!!
            return 0;
        }
        while (A.size() > 1) {
            int tmp = A.poll();
            B.offer(tmp);
        }
        // 当上面的循环结束, 此时 A 中就只剩一个元素了.
        // 把这个最后的元素就作为出栈的结果即可.
        int ret = A.poll();

        // 这个操作是唯一的区别.
        B.offer(ret);

        // 最终完成操作之后, 要交换 A 和 B 的身份. 保证下次入栈的时候, 还是往 A 中插入.
        swapAB();
        return ret;
    }

    /** Returns whether the stack is empty. */
    public boolean empty() {
        return A.isEmpty() && B.isEmpty();
    }
}

2:用栈实现队列==>https://leetcode-cn.com/problems/implement-queue-using-stacks/


class MyQueue {
    Stack<Integer> A = new Stack<>();
    Stack<Integer> B = new Stack<>();

    /** Initialize your data structure here. */
    public MyQueue() {

    }

    /** Push element x to the back of queue. */
    public void push(int x) {
        // 入队列的时候, 需要先把 B 中的元素都倒腾到 A 中, 再往 A 中插入新元素
        while (!B.isEmpty()) {
            int tmp = B.pop();
            A.push(tmp);
        }
        A.push(x);
    }

    /** Removes the element from in front of queue and returns that element. */
    public int pop() {
        if (A.isEmpty() && B.isEmpty()) {
            return 0;
        }
        // 先把 A 的所有元素都倒腾到 B 中, 然后再通过 B 进行 pop
        while (!A.isEmpty()) {
            int tmp = A.pop();
            B.push(tmp);
        }
        // 删除 B 中的元素
        return B.pop();
    }

    /** Get the front element. */
    public int peek() {
        if (A.isEmpty() && B.isEmpty()) {
            return 0;
        }
        while (!A.isEmpty()) {
            int tmp = A.pop();
            B.push(tmp);
        }
        // 删除 B 中的元素
        return B.peek();
    }

    /** Returns whether the queue is empty. */
    public boolean empty() {
        return A.isEmpty() && B.isEmpty();
    }
【数据结构|C语言版】栈和队列
GUIQU的博客
05-09 2703
各位小伙伴大家好！上次小编给大家讲解了数据结构中的重要基础：算法效率和复杂度分析，接下来我们讲解一下栈和队列！【知识框架】以上就是小编对栈和队列的讲解。如果觉得小编讲的还可以，还请一键三连。互三必回！持续更新中~！
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 29万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
数据结构——栈和队列
2302_80250536的博客
03-10 1150
可以使用。
栈和队列经典面试题
bit_zyx的博客
04-07 3310
目录 1、括号匹配问题 2、用队列实现栈 3、用栈实现队列 4、设计循环队列 1、括号匹配问题 链接直达： 有效的括号 题目： 思路： 2、用队列实现栈 3、用栈实现队列 4、设计循环队列 ...
栈和队列的概念
stormsunshine的博客
04-14 4532
文章目录栈、队列和双端队列栈队列双端队列Java 中的栈、队列和双端队列单调栈和单调队列二叉堆和优先队列二叉堆优先队列 栈、队列和双端队列 栈和队列是常见的数据结构。栈的特点是后进先出，添加元素、删除元素和查看元素都在栈顶操作。队列的特点是先进先出，添加元素在队尾操作，删除元素和查看元素在队首操作。 双端队列比栈和队列更加灵活，可以在双端队列的两端添加元素、删除元素和查看元素。 栈、队列和双端队列都满足每次添加元素、删除元素和查看元素的时间复杂度是 O(1)O(1)O(1)。 栈、队列和双端队列都可以基于数
【数据结构】栈和队列超详细讲解
Become Mad的博客
05-27 2822
我们已经学习了顺序表、链表、数组等数据结构，今天我们再来认识一下栈和队列两种新的数据结构，一起来看看吧~
顺序表、链表、栈和队列总结
ljw的博客
06-08 1773
顺序表、链表、栈和队列都是线性数据结构，但它们在管理和访问数据方面有不同的特点和用途。的结构实现更优一些，因为如果使用数组的结构，出队列在数 组头上出数据，效率会比较低。链表是由一系列节点组成，每个节点包含数据域和指向下一个节点的指针。是一种线性表，在C语言中通常通过数组来实现。的结构实现更优一些。栈的实现一般可以使用数组或者链表实现，相对而言。队列是一种先进先出（FIFO）的数据结构。栈是一种后进先出（LIFO）的数据结构。队列也可以数组和链表的结构实现，使用。下面是一个简单的顺序表在C语言中的。
数据结构之栈和队列(超详解)
egoist2023的博客
02-03 2347
详解栈和队列的底层和使用及涉及的相关题型
栈和队列＜数据结构 C版＞
hukang的博客
07-27 2406
栈是一种特殊的线性表，其只允许在特定的一端进行插入和删除操作。 队列也是一种特殊的线性表，其在一端进行插入操作，另一端进行删除操作。
JavaScript【栈和队列】
m0_63077733的博客
03-20 1774
数组是一个线性结构，并且可以在数组的任意位置插入和删除元素。而栈和队列就是比较常见的受限的线性结构。如下图所示：栈的特点为先进后出，后进先出程序中的栈结构：函数调用栈：A（B（C（D（））））：即A函数中调用B，B调用C，C调用D；在A执行的过程中会将A压入栈，随后B执行时B也被压入栈，函数C和D执行时也会被压入栈。所以当前栈的顺序为：A->B->C->D（栈顶）；函数D执行完之后，会弹出栈被释放，弹出栈的顺序为D->C->B->A;递归：为什么没有停止条件的递归会造成栈溢出？
make 函数概述与内部配置详解
sqym1的博客
09-01 630
函数在切片、映射、通道三种核心引用类型的参数化配置，可以精细控制内存分配策略、并发同步行为以及运行时性能表现。：基于同一底层数组，可通过切分创建多个互不影响数据地址的切片视图。，减少再散列（rehash）次数和链长度，保证查找与插入性能。，但内部 1<<B 个桶已就绪，可高效插入前 16 对映射。标记结束，接收方可读出剩余缓存并返回零值，不再阻塞。，底层按照倍增策略重新分配更大数组，复制旧数据。，并据此分配内部桶（bucket）的数量，，并保证对象已被初始化，直接可用。切片：分配底层数组，并返回对应的。
GDPU操作系统实验：生产者消费者问题
平平无奇的小甜菜
08-31 1264
本文摘要：实验通过信号量机制实现生产者-消费者模型，建立大小为10的缓冲区，使用3个生产者线程随机生成大小写字母，2个消费者线程取出字符。通过empty、full和mutex信号量实现同步与互斥，确保缓冲区访问安全。进阶实验扩展为选择性消费，增加3类消费者（仅小写/仅大写/任意字符），通过额外信号量管理不同类型产品。实验验证了进程同步中共享资源管理的有效性，演示了环形缓冲区和多线程协调的实现方法，为操作系统并发控制提供了实践案例。（149字）
第二章 Windows 核心概念通俗解析
最新发布
YJlio的博客
09-03 898
本文通俗解析了Windows核心概念，帮助理解Sysinternals工具背后的原理。主要内容包括：管理员权限与UAC机制、进程线程与作业的区别、用户模式与内核模式的切换、句柄的作用机制、应用隔离技术（MIC和App Container）、受保护进程特性、调用栈与符号的重要性，以及会话窗口机制和UIPI安全防护。通过生活化比喻和记忆口诀，将复杂的Windows内核原理转化为易于理解的知识点，为使用Sysinternals工具进行系统诊断提供理论基础。掌握这些核心概念能更准确地解读工具数据，快速定位系统问题。
【开题答辩全过程】以 基于SSM的电竞设备商城设计与开发为例，包含答辩的问题和答案
shiji7553的博客
09-03 271
这是一篇关于计算机专业毕业设计答辩的摘要。文中介绍了一位14年经验的资深毕设内行人，擅长Java、PHP、微信小程序、Python、Golang、安卓Android等多种开发语言，项目涉及大数据、深度学习、网站、小程序、安卓系统、算法等。该内行人还提供项目定制开发、代码讲解、答辩教学、文档编写、降重技巧等服务。 在答辩过程中，学生详细介绍了其基于SSM框架开发的电竞设备商城系统，包括用户角色划分、功能模块设计、技术选型依据（Java/SSM/HTML/CSS/MySQL/B-S架构）以及安全措施（MD5加盐
Java-面试八股文-Mysql篇
2302_81048526的博客
08-29 1905
隔离级别脏读不可重复读幻读性能读未提交(RU)✅✅✅高读已提交(RC)❌✅✅较高可重复读(RR)❌❌✅(InnoDB 可避免)中串行化❌❌❌低特性悲观锁乐观锁思想假设一定会冲突假设大部分不会冲突实现for update、数据库排他锁、Java同步锁版本号 / 时间戳机制并发性能低高适用场景写多、冲突频繁读多写少、冲突少函数运算要避免，隐式转换要小心不等、OR、前模糊，索引基本挂掉联合索引最左前缀，范围之后不再用区分度低索引没用，优化器说了算对比项。
Android Handler 消息循环机制
w2064004678的博客
09-03 797
核心思想：利用 Linux 的epoll机制，在无事可做时让线程进入休眠，在有新消息时能及时唤醒，从而兼顾了响应效率和资源消耗。
Java--json与map，colloct与流
m0_73721715的博客
09-03 738
exchange.getBody().getPayload().toJSONString(), // 1. 先将payload转为JSON字符串。// 这里其实应该用 JSON.toJSONString(paramMap)，但JSONObject.toJSONString()也可以。exchange.getBody().getPayload().toJSONString(), // JSON字符串。// 将JSON数组字符串转换为对象列表。// 将对象转换为JSON字符串。// 创建JSONObject。
2025年- H108-Lc216--57.插入区间(贪心)--Java版
zsysingapore的博客
09-02 389
其他没有重叠的区间直接加入到新的intervals。第1个区间的右边界的值大于第2个区间左边界的值。新区间的右边界，要选两个重叠区间值大的右边界。
Java 异步任务工厂（一）核心架构设计与基础实现
Yeats_Liao的博客
09-03 1390
Java 异步任务工厂（一）核心架构设计与基础实现
栈和队列实现代码解析
在计算机科学中，栈（Stack）和队列（Queue）是最基础的数据结构之一。它们以特定的方式存储数据，并为数据提供有限的访问方式。栈是一种后进先出（LIFO）的数据结构，而队列是一种先进先出（FIFO）的数据结构。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值