队列Queue

已于 2022-08-02 10:16:20 修改
阅读量486 收藏 1
点赞数 2
分类专栏： 数据结构 文章标签： 链表 java 数据结构
于 2022-06-18 19:00:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mu_tong_/article/details/125350342
版权

文章目录

队列 Queue

在这里插入图片描述

队列的 概念与 特点 先进先出

概念队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First
In First Out) 入队列：进行插入操作的一端称为队尾（Tail/Rear） 出队列：进行删除操作的一端称为队头
在这里插入图片描述

Queue 实现的两个接口

在这里插入图片描述

Deque 和 Queue

来看LinkedList(底层是一个双向链表) 实现了 两个接口 一个是

Deque 和 Queue
在这里插入图片描述

Queue的常用方法

1.添加元素 offer 与 add

public class Main {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        queue.add(1);
        queue.offer(2);
        System.out.println(queue.peek());
        System.out.println(queue.element());

    }
}

2.获取队头元素 peek 和 element

public class Main {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        queue.add(1);
        queue.offer(2);
        System.out.println(queue.peek()); 1
        System.out.println(queue.element()); 1

    }
}

在这里插入图片描述

3出队列 poll 和 remove

public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        queue.add(1);
        queue.offer(2);
        System.out.println(queue.peek());
        System.out.println(queue.element());
        System.out.println(queue.poll());
        System.out.println(queue.remove());
        System.out.println(queue);
        
    }

在这里插入图片描述

4.添加 删除 查看 队头 元素 方法的区别

在这里插入图片描述

这里 添加元素 一般 用的比较多 的是 offer
在这里插入图片描述
双端队列 Deque
在这里插入图片描述
双端队列的部分方法

public class Main {
    public static void main(String[] args) {
        Deque<Integer> deque = new LinkedList<>();
        deque.offerLast(1); // Last 尾部 入队
        deque.offerFirst(2);// First 头入队
        deque.offer(3);// 默认队尾入队
        System.out.println(deque.peekFirst());
        System.out.println(deque.peekLast());
        System.out.println(deque);
    }
}

看完了 双端队列，知道了 LinkedList，底层是一个双向链表那么 回顾一下一看是 我们学习的 ArrayList 顺序表
这里 我们 在这里做一个小总结 ，

ArrayList 与 LinkedList 的 区别

从增删查改 的 角度 来看 ，ArrayList 底层 是一个数组，每次 删一个元素 ，是通过移动元素 完成，而LinkedList 是 链表结构，删除元素只需要 让上一个节点指向

这个节点的下一个节点，在指定位置添加 同理 ，ArrayList 还是 通过 移动元素 来完成添加，而 LinkedList 只需要改变节点的指向即可。

另外 ArrayList 在 内存中是连续的，而LinekdList 在 内存中 不是连续的（看上去是连续的，但是每个节点代表一块空间，通过引用连接在一起，所以他不是连续的）
了解完了这么多 那么 我们 来 分 三种方式 来实现我们字节 的队列

实现自己的队列

在这里插入图片描述

1.单链表实现

class Node {
    public int val;
    public  Node next;
    public Node(int val) {
        this.val = val;
    }
}
// 使用单链表实现队列
public class MyQueue {
    // 标记头
    public Node head;
    // 标记 尾
    public  Node last;

    public void offer(int val) {
        Node node = new Node(val);
        if(head == null) {
         head = node;
         last = node;
        }else {
            last.next = node;
            last = last.next;
        }
    }
    public int poll() {
        if(isempty()) {
            throw new RuntimeException("队列为空");
        }
        int oldVal = head.val;
        this.head = head.next;
        return oldVal;
    }
    public int peek() {
        if(isempty()) {
            throw new RuntimeException("队列为空");
        }
        int oldVal = head.val;
        return oldVal;
    }
    public boolean isempty() {
        return this.head == null;
    }

    @Override
    public String toString() {
        return "MyQueue{" +
                "head=" + head +
                ", last=" + last +
                '}';
    }
}

测试用例

public class Test {
    public static void main(String[] args) {
        MyQueue queue = new MyQueue();
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);
        System.out.println(queue.peek());//1
        System.out.println(queue.poll());//1
        System.out.println(queue.poll());//2
        System.out.println(queue.poll());//3
        System.out.println(queue.poll());//异常

    }
}

在这里插入图片描述

2.双向链表实现

class Node {
    public int val;
    public Node next;
    public Node prev;
    public Node(int val) {
        this.val = val;
    }
}
// 使用双向链表实现栈
public class MyQueue2 {
    // 标记头
    public Node head;
    public Node cur;
    public void offer(int val) {
        Node node = new Node(val);
        if(cur == null) {
            head = node;
            cur = node;
        }else {

            cur.next = node;
            node.prev = cur;
            cur = cur.next;

        }
    }
    // 删除队头元素
    public int poll() {
        if(isEmpty()) {
            throw new RuntimeException("队列为空无法删除");
        }
        int oldVal = head.val;

        head.prev = null;

        this.head = head.next;

        return oldVal;
    }
    public int peek() {
        if(isEmpty()) {
            throw new RuntimeException("队列为空无法删除");
        }
        int oldVal = head.val;
        return oldVal;
    }
    public boolean isEmpty() {
        return this.head == null;
    }

}

测试用例

public class Test {
    public static void main(String[] args) {
        MyQueue2 queue = new MyQueue2();
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);
        queue.offer(4);
        System.out.println(queue.peek());//1
        System.out.println(queue.poll());//1
        System.out.println(queue.poll());//2
        System.out.println(queue.poll());//3
        System.out.println(queue.poll());//4
        System.out.println(queue.poll());//异常

    }
}

在这里插入图片描述
通过链表实现完 队列，有没有想过 使用 数组来实现 队列呢？？
在 实现数组 实现 队列 的时候 我们 要先学习一个 循环队列 ，要不 我们很难实现 队列

引出 循环队列

在这里插入图片描述

先来看一下 环形队列

在这里插入图片描述
接下来看 一下我们的小手段

数组下标循环的小技巧

  1. 下标最后再往后(offset 小于 array.length):

    index = (index + offset) % array.length

在这里插入图片描述
7 走 到 2 的偏移量 offset 为 4 通过 公式 （index+ offset）% arraylength = （7 + 4） % 9 = 11 % 9 = 2
在这里插入图片描述

循环队列判满的三种方法

在这里插入图片描述

第一种解决方式 使用 usedSize

在这里插入图片描述

第二种 解决方式 使用标志位

创建一个boolean 变量flag 先 赋值 为 false rear每次 走 一步 flag 赋值为 true 知道 front 与 rear 相遇如果 flag 为 true 数组就为 满 ，

front 每次 走一步 flag 赋值为 false 当front 与 rear 相遇 且 flag 为false 数组就为空
在这里插入图片描述

第三种 浪费一个格子判断空和满

在这里插入图片描述
在这里插入图片描述
了解 了 这么 多 循环队列的 知识 那么 我们直接 上oj题
在这里插入图片描述
在这里插入图片描述
那么 开始 吧

设计循环队列

入队 和 判断队列是否满
在这里插入图片描述
出队 和 判断 数组 是否为空，获取 队头 和 队尾下标
在这里插入图片描述
完成了 方法 我们 放到 oj 上来 跑
在这里插入图片描述
结果发现 错误 这里 不要机 我们 来 观察 输出 和 预计 结果

接下来我们 要观察一下 oj 上 给的 错误信息
在这里插入图片描述

class MyCircularQueue {
        public int[] elem;
        public int front; // 队头
        public int rear; // 队尾

    public MyCircularQueue(int k) {
        this.elem = new int[k+1];
    }

    // 入队
    public boolean enQueue(int value) {
        if(isFull()) return false;
       this.elem[rear] = value;
        rear =   (rear + 1) % elem.length;
        return true;
    }

    public boolean deQueue() {
        if(isEmpty()) return false;
        front = (front + 1) % elem.length;
        return true;
    }

    /**
     * Front得到队头元素
     * @Front
     */
    public int Front() {
        // 这里 oj 上 判断 数组是否为空不用抛异常 同一返回-1即可
        if(isEmpty()) {
            return -1;
        }
        return elem[front];
    }

    public int Rear() {
        if(isEmpty()) {
            return -1;
        }
        int index = -1;
        
        if(rear == 0) {
            index = elem.length - 1;
        }else {
            index = rear - 1;
        }
        return elem[index];

    }

    public boolean isEmpty() {
        return front == rear;
    }

    public boolean isFull() {
        if((this.rear+1)%elem.length == front) {
            return true;
        }
        return false;
    }
}

方法二 使用 suedSize 来 解题

// 使用 usedSize
public class MyCircularQueue {
    public int[] elem;
    public int front;
    public int rear;
    int usedSize;
    public MyCircularQueue(int k) {
        this.elem = new int[k];
    }

    public boolean enQueue(int value) {
        if(isFull()) return false;

        this.elem[rear] = value;
        rear = (rear+1) % elem.length;
        usedSize++;
        return true;
    }
    这里每次添加 rear 都 会 向后 一步 入 先 0 下标 添加完 1 执行rear = (rear+1) % elem.length; 就会指向2 那么 查找尾节点，就可以 返回
        elem[rear - 1] , 但是 有一个特里 就是 当 rear 为 0 时 就需要 返回下标为 elem。length 的值 这里加个if 语句就ok

    public boolean deQueue() {
        if(isEmpty()) return false;
        front = (front + 1) % elem.length;
        usedSize--;
        return true;
    }

    public int Front() {
        if(isEmpty()) return -1;
        return elem[front];
    }

    // 获得队尾元素
    public int Rear() {
        if(isEmpty()) return -1;


        int index = -1;
        if(rear == 0) {
            index = elem.length - 1;
        }else {
            index = rear - 1;
        }
        return elem[index];
    }

    public boolean isEmpty() {
        return usedSize == 0;
    }

    public boolean isFull() {
        return usedSize == elem.length;

    }


}

在这里插入图片描述
最后 还有一种 通过 标志位 来判 满 的 可以 尝试一下 这就 不给 出答案 ，因为我没去写嘿嘿
在这里插入图片描述
完成了循环队列 ，差不多 用数组 来实现 队列 就是这样那么接下来 趁热打铁继续 冲 oj题

用队列实现栈

class MyStack {
    // 通过队列来实现栈
    //不为空的进 ，为空出
    Queue<Integer> que1 ;
    Queue<Integer> que2 ;
    public MyStack() {
        que1 = new LinkedList<>();
        que2 = new LinkedList<>();
    }

    public void push(int x) {
        if(!que1.isEmpty()) {
            que1.offer(x);
        }else if(!que2.isEmpty()) {
            que2.offer(x);
        }else {
            que1.offer(x);
        }
    }

    public int pop() {
        if(empty()) return -1;
       if(!que1.isEmpty()) {
         int  size = que1.size() - 1;
           for(int i = 0;i<size;i++) {
               int ret = que1.poll();
               que2.offer(ret);
           }
           return que1.poll();
       }else {
           int  size = que2.size() - 1;
           for(int i = 0;i<size;i++) {
               int ret = que2.poll();
               que1.offer(ret);
           }
           return que2.poll();
       }
    }

    public int top() {
        if(empty()) return -1;
        int ret = 0;
        if(!que1.isEmpty()) {
            int  size = que1.size();
            for(int i = 0;i<size;i++) {
               ret = que1.poll();
                que2.offer(ret);
            }
            return ret;
        }
        if(!que2.isEmpty()) {
            int  size = que2.size();
            for(int i = 0;i<size;i++) {
                ret = que2.poll();
                que1.offer(ret);
            }
            return ret;
        }
        return -1;
    }

    public boolean empty() {
        return que1.isEmpty()&&que2.isEmpty();
    }
}

在这里插入图片描述
队列实现了 栈 那么 用栈来实现 队列 不是一个道理 吗 同样使用

两个 栈 来实现 队列

我们先来了解一下逻辑
在这里插入图片描述
了解了 逻辑 那么直接上 oj 干就行了

用栈实现队列

class MyQueue {

      public Stack<Integer> stack1;
    //入队列的栈
    public Stack<Integer> stack2;
    //出队列的栈

    public MyQueue() {
    stack1 = new Stack<>();
    stack2 = new Stack<>();
    }

    public void push(int x) {
    stack1.push(x);
    }

    public int pop() {
        if(empty()) return -1;
        if(!stack2.empty()) {
           int ret =  stack2.pop();
            return ret;
        }else {
            int size = stack1.size();
            for(int i = 0;i<size;i++) {
                int ret = stack1.pop();
                stack2.push(ret);
            }
            return stack2.pop();
        }
    }

    
    public int peek() {
        if(empty()) return -1;
        if(!stack2.empty()) {
            int ret =  stack2.peek();
            return ret;
        }else {
            int size = stack1.size();
            for(int i = 0;i<size;i++) {
                int ret = stack1.pop();
                stack2.push(ret);
            }
            return stack2.peek();
        }
    }

    public boolean empty() {
        return stack1.empty() && stack2.empty();
    }
}

在这里插入图片描述
其实 队列 与 栈 的 要学习的 东西 不多 多的 事 如何 去使用他，向 栈 还有 单调栈 ，就是 栈顶 到 栈 低 成一个 单调递增或单调递减的趋势，我们 要知道 栈和队列的 特点 ，栈 : 先进 后出 队列 ： 先进先出 ，在 去 使用栈和 队列 解决 些 练习题 就能很好的熟知他们。
在这里插入图片描述

牧..
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
消息队列 Queue与Topic区别.docx
02-23
消息队列 Queue与Topic区别
Java队列
CrazyQiQi的博客
03-01 400
Java队列队列基本用法leetcode实战1. 用队列实现栈解题思路代码 队列基本用法 Queue<Integer> queue = new LinkedList<Integer>() // 创建队列 queue.add(1) // 添加元素，超出范围抛出异常 queue.offer(1) // 添加元素，超出范围返回 false queue.remove() // ...
队列(Queue）的详解
m0_53677355的博客
10-23 3236
双端队列是指允许两端都可以进行入队和出队的操作的队列，Deque是一个接口，使用时必须创建LinkedList的对象。底层还是一个数组，指定一个队列的大小，入队时，当队列满的时候就不能再放了，出队时当队列为空的时候就不能再出队了。队列，在Java中是用双向链表实现的，实现类是LinkedList，性质是先进先出 FIFO。队列：只允许在一端进行插入操作，在另一端进行删除数据操作的特殊的线性表，队列具有先进先出。注意：栈，在Java中是用数组实现的，Stack继承自Vector，性质是后进先出 LIFO。
java中的队列-Queue
橙煦媛的博客
11-24 283
import java.util.LinkedList; import java.util.Queue;Queue <Integer> q = new ArrayList<Integer>(); Queue接口与List、Set同一级别，都是继承了Collection接口。 LinkedList实现了Queue接 口。 BlockingQueue 继承了Queue接口。 队列是一种数据结构．它有两个
队列(Queue)
jakelihua
10-11 170
本文从题目出发，带领大家快速入门，Java中的自带API，Queue的使用。
【JAVA】leetcode刷题基础：Queue队列（Queue、PriorityQueue）
AXIMI的博客
04-23 1179
PriorityQueue PriorityQueue保存队列元素的顺序不是它们加入队列的顺序，而是他们的大小（默认poll的顺序是从小到大）。所以使用peek()、poll()函数取出队列中的元素时，不是取出最先存进去的元素而是所有元素中最小的元素。 同时PriorityQueue不允许插入null元素，他存储的元素必须是可以比较的对象，否则要指明比较器。 PriorityQueue实现自定...
数据结构---队列
m0_58342797的博客
02-07 627
目录 队列的概念 队列实现 队列的模拟实现 使用双向链表来实现 使用数组来实现---循环队列 双端队列 队列的概念 队列：有特殊限制的线性表，只可以在表的前端进行删除操作，表的后端进行插入操作。 队列：先进先出表头删除，表尾插入（排队买饭） 队列实现 add/offer---队尾添加元素 public static void main(String[] args) { Queue<Integer> queue = new ...
Java 队列
BombBomb666的博客
09-19 225
Java 队列
Java的Queue和Deque
小威的博客
12-14 839
文章目录继承关系Queue添加元素取出元素推荐使用Deque添加元素取出元素 继承关系 Queue Queue<Integer> queue = new LinkedList<Integer>(); 添加元素 queue.add(1); queue.offer(1); 区别：在容量已满的情况下，add() 方法会抛出IllegalStateException异常，offer() 方法只会返回 false 。 取出元素 queue.remove(); queue.poll();
数组队列
微信公众号：饺子泡牛奶
11-12 445
章节目录： 一、队列 1.1 概述 二、数组顺序队列 2.1 实现思路 2.2 代码示例 2.3 问题分析及优化 三、数组环形队列 3.1 实现思路 3.2 代码示例
用VB实现循环队列算法
lyserver的专栏
05-04 4927
在日常代码编制时，许多人会忽略一些最基本的算法，导致代码冗余，思路不清楚。我曾经至少两次在CSDN里遇到这类问题：我想在页面的右边显示一个列表，列表长度为20，新加入一个用户后，显示在列表开头，再加入的用户，显示在这个用户的下边，当用户数量超过20后，挤掉最前面的那一位，第二位加入的用户成了第一位，依次循环，保证列表最多显示20位用户。当然，实际问题可能与此有些出入，比如Coder是想显示网友们最
python队列queue模块详解
09-20
主要为大家详细介绍了python队列queue模块的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C#队列Queue用法实例分析
12-31
本文实例分析了C#队列Queue用法。分享给大家供大家参考。具体分析如下： 队列（Queue）在程序设计中扮演着重要的角色，因为它可以模拟队列的数据操作。例如，排队买票就是一个队列操作，后来的人排在后面，先来的人...
c#队列Queue学习示例分享
09-04
队列Queue,先进先出，先生产的货物先出货，后生产的货物后出货，下面看示例学习c#队列Queue
ZooKeeper实现分布式队列Queue
03-03
现在硬件越来越便宜，一台非品牌服务器，2颗24核CPU，配48G内存，2T的硬盘，已经降到2万块人民币以下了。这种配置如果简单地放几个web应用，显然是奢侈的浪费。就算是用来实现单节点的hadoop，对计算资源浪费也是...
【一起来学数据结构Java】队列
weixin_51574797的博客
01-19 363
一起来学java数据结构——队列 文章目录一起来学java数据结构——队列队列的实现特殊的队列（deque)Queue的方法add和offerremove和pollelement和peekdeque的用法用链表实现queue循环队列用队列实现栈用两个栈实现队列疑惑 队列的特点就是先进先出 队列的实现 队列的特点就是先进先出 队列可以使用链表或者数组来实现。 Queue<Integer> queue=new LinkedList<>(); Queue<Integer> qu
利用数组实现队列（超级简单）
qq_45804132的博客
04-14 1226
数组实现队列 我们之前既然已经说过可以用链表实现队列，那么我也知道队列就是一种表，那么自然的，也可以用数组实现队列，上代码：后讲解 /*队列的数组实现*/ /*头文件*/ #include<stdio.h> #include<stdlib.h> #define error(str) fprintf(stderr,"%s",str),exit(1)//自定义报错信息 typ...
JAVA队列（Queue）用法附实例讲解
This_pro的博客
08-27 2988
一、功能 队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。 二、声明 1、声明一个栈的写法，E表示数据类型，name是你给队列起的名字，LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用。 Queue <E> name = new LinkedList<E>(); 2、实例：声明一个名为queue的Integer队列 Queue<Integer> queue = new LinkedLi
【数据结构Java版】Queue队列的活用
m0_63372226的博客
12-16 1091
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)入队列：进行插入操作的一端称为队尾（Tail/Rear）出队列：进行删除操作的一端称为队头（Head/Front）查看队头元素：peek队列：java中，队列的含义被淡化了，队列使用Queue接口来表示。
python消息队列Queue
最新发布
07-27
Python中的消息队列可以使用内置的Queue模块来实现。Queue模块提供了多种队列实现，包括先进先出（FIFO）队列、后进先出（LIFO）队列和优先级队列。 要使用Queue模块，首先需要导入它： ```python from queue ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值