队列Queue

已于 2022-08-02 10:16:20 修改
阅读量531 收藏 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();
    }
}

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

牧..
关注
专栏目录
queue
zylg
08-06 156
queue 单向队列,从一端存,从列一段取 1 生成构造 2 操作 2.1 大小和容量 2.2 比较 2.3 find 2.4 截取部分 2.5 增,插,删,改 /* * use QQueue on qt,but c++ is queue * constructor empty size * front ...
java队列——queue详细分析
weixin_30443895的博客
11-22 6738
Queue： 基本上，一个队列就是一个先入先出（FIFO）的数据结构 Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Deque接 口。 Queue的实现 1、没有实现的阻塞接口的LinkedList： 实现了java.util.Queue接口和java.util.AbstractQueue接口　　内置的不阻塞队列： Pri...
Queue_温故知新
最新发布
wowangz的专栏
09-20 618
虽然queue模块中的队列类型在高层抽象上提供了相似的接口和方法，但它们的底层实现和内部机制各不相同，以适应不同的使用场景和需求。Queue和LifoQueue可能基于实现，而则更可能基于堆数据结构实现。所有这些实现都考虑了线程安全，以确保在多线程环境中使用时不会出现数据竞争和一致性问题。
Queue
dianwu8711的博客
09-28 155
using System; using System.Collections.Generic; using System.Text; using System.Collections; //using System.Collections.Generic.Queue(int); namespace Queue { class Program { ...
C#队列Queue用法实例分析
12-31
本文实例分析了C#队列Queue用法。分享给大家供大家参考。具体分析如下： 队列（Queue）在程序设计中扮演着重要的角色，因为它可以模拟队列的数据操作。例如，排队买票就是一个队列操作，后来的人排在后面，先来的人...
设一循环队列Queue，只有头指针front，不设尾指针，另设一个内含元素个数的计数器，试写出相应的进队、出队算法。
04-04
设一循环队列Queue，只有头指针front，不设尾指针，另设一个内含元素个数的计数器，试写出相应的进队、出队算法。
python队列queue模块详解
09-20
在Python中，`queue`模块提供了三种类型的队列：`Queue`（默认），`LifoQueue`（后进先出，类似栈），和`PriorityQueue`（优先级队列）。 首先，让我们详细了解一下`Queue`类的初始化函数`__init__(self, maxsize=0...
C#队列Queue多线程用法实例
09-03
在C#编程中，队列（Queue）...总结来说，这个实例展示了如何在C#中使用队列Queue进行多线程编程，包括创建队列、入队、出队以及创建和启动线程。理解这些基本概念和操作对于开发涉及多线程和队列的C#应用程序至关重要。
python 队列Queue的使用 python2例程展示了队列Queue的使用过程，供学习参考使用
08-18
Python中的`queue`模块提供了多种类型的队列，包括`Queue`（默认限制大小）、`LifoQueue`（后进先出，类似堆栈）和`PriorityQueue`（优先级队列）。这些队列都实现了线程安全的`put()`和`get()`方法，用于添加和获取...
Queue（队列）
weixin_53909781的博客
10-26 93
Queue - Array Implementation 代码：Ubuntu Pastebin 我们创建一个队列的对象和写一些最基本的函数： 我们先写一个在队列中插入元素的函数： 先创建一个长度为2的队列，再给它插入三个值，结果如下： 接着再写一个删去队尾元素的函数： 运行： 可以看到本来已经满了的队列，此时又可以添加新的元素了。 接着再写输出队列头部和尾部的函数： 最后再来总体运行一次： Queue-Linked List Imple...
Simple Queue
jessiaflora的博客
11-30 445
Simple QueueProblem Implement a queue. Input some number means action.(End with EOF) 1 means push into the queue. Promise that another integer will follow it, meaning the value to push. If the
队列（queue）
zxl200410的博客
03-21 452
什么是对列
【JZOJ5924】Queue
sadnohappy
10-24 216
Description 给一个序列，支持区间轮换（即末尾的一个数挪到开头），查询区间等于k的有多少个。 Solution 分块，记si,js_{i,j}si,j​为第iii块jjj出现的次数，每个块维护一个链表，修改就是对O(n)O(\sqrt n)O(n​)的块进行修改，用deque实现非常方便。 当然也可以打非旋转Treap，每个点维护权值线段树，合并的时候向上线段树合并。 也有离线做法，先用...
【Hazelccast】Queue
Mr_EvanChen的Blog
07-06 684
队列样例package com.cqh.Hazelcast_Queue; import com.hazelcast.core.Hazelcast; import com.hazelcast.core.HazelcastInstance; import java.util.concurrent.BlockingQueue; import java.util.concurrent.TimeUnit...
Queue 队列
记录
05-14 117
Queue封装好的类 本质是一个object数组 先进先出 后进后出 类似排队 队伍中第一个人先吃到饭 （正常情况下） 使用时需要引用 using System.Collections; Queue queue = new Queue(); 增加 queue.Enqueue(1); 取出 取出队头元素 Console.WriteLine(queue.Dequeue()); 查看 查看对头元素 但不移除 Console.WriteLine(queue.Peek()); 查看元素是否在队列中 Console.
Python多线程安全队列queue模块深度解析
"Python队列queue模块的详细介绍及使用方法" Python的queue模块提供了一种线程安全的数据结构，主要用于多线程环境中的数据共享和通信。这个模块包含各种类型的队列，如FIFO（先进先出）队列、LIFO（后进先出）队列...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值