【Java---数据结构】队列

最新推荐文章于 2023-10-18 13:39:31 发布

潇湘夜雨.

最新推荐文章于 2023-10-18 13:39:31 发布

阅读量1.6k

点赞数 9

文章标签：数据结构 Queue java

本文链接：https://blog.csdn.net/qq_45058331/article/details/123155191

版权

一、队列

🧊队列的概念

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表。
队列具有先进先出的特点 FIFO(FirstIn First Out)
入队列：进行插入操作的一端称为队尾（Tail/Rear）
出队列：进行删除操作的一端称为队头（front）

🧊队列的术语

队尾：插入元素的一段
队头：删除元素的一段
入队：向队列中插入新的元素，新的元素入队后就会成为新的队尾。
出队：从队列中删除元素，元素被删除（出队）后，它的下一个元素就会成为新的队头。

二、普通队列(Queue)

队列可以使用数组或链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。

🧊队列的方法

🍓入队列：add()、offer()

相同：未超出容量，从队尾压入元素，返回压入的那个元素。
区别：在超出容量时，add()方法会对抛出异常，offer()返回false

🍓出队列：remove()、poll()

相同：容量大于0的时候，删除并返回队头被删除的那个元素。
区别：在容量为0的时候，remove()会抛出异常，poll()返回null

🍓获取队头元素(不删除)：element()、peek()

相同：容量大于0的时候，都返回队头元素。但是不删除。
区别：容量为0的时候，element()会抛出异常，peek()返回null。

🧊方法的使用

🌊代码示例

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

public class TestDemo {
    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());
    }
}

运行结果：
1
1
1
2

🧊模拟实现普通队列

✨使用单链表实现

🌊代码示例

class Node{
    public int val;
    public Node next;
    public Node(int val){
        this.val = val;
    }
}

public class MyQueue {
    public Node head;
    public Node last;

    /**
     * 入队
     * @param val 插入的元素
     */
    public void offer(int val){
        Node node = new Node(val);
        if(this.head==null){
            this.head = node;
            this.last = node;
        }else {
            last.next = node;
            last = last.next;
        }
    }

    /**
     * 出队
     * @return 返回出队的元素
     */
    public int poll(){
        if(isEmpty()){
            throw new NullPointerException("队列为空");
        }
        int oldVal = this.head.val;
        this.head = this.head.next;
        return oldVal;
    }

    /**
     * 判断队列是否为空
     * @return 空返回 true，否则返回false
     */
    public boolean isEmpty(){
        return this.head==null;
    }

    /**
     * 获取队头元素
     * @return 返回队头元素
     */
    public int peek(){
        if(isEmpty()){
            throw new NullPointerException("队列为空");
        }
        return this.head.val;
    }
}

🌊测试代码

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

运行结果：
1
1
2
3
Exception in thread "main" java.lang.NullPointerException: 队列为空
	at MyQueue.poll(MyQueue.java:41)
	at Test.main(Test.java:18)

三、循环队列

🧊循环队列的介绍

队列可以使用链表实现，队列也可以使用顺序表（数组）实现。
如果使用顺序表实现，会存在一个问题：顺序表空间利用不充分。因为每次出队都会浪费一个空间，为了解决这个问题，所以采用循环队列。
循环队列入队时能够重新从顺序表的尾部跳到顺序表头部对已经出队的空间重新利用，这样就能够保证顺序表的每一个空间都可以被利用。

🧊数组下标循环技巧

🍎数组下标从后面的位置循环到前面的位置：

(offset 小于 array.length)：index = (index + offset) % array.length
offset：偏移量
移动后的位置 = （移动前的位置+偏移量）% 数组长度

🍎数组下标从前面的位置倒着走到后面的位置：

index = (index + array.length - offset) % array.length
移动后的位置 = （移动前的位置+数组长度-偏移量）% 数组长度

队列在移动时偏移量都是1，所以只要把公式中的offset都改为1即可。

🧊循环队列图

💦如果将队列看做是一个循环，那么就可以看做是将数据存储在一个圆环里。

⚡有一个问题，当队列（数组）满的时候，font = rear

🧊如何区分循环队列是满还是空

1、定义一个变量size：记录队列元素个数。

每存放（入队）一个元素size++，每删除（出队）一个元素size--。
当size的值与顺序表的大小相等时，表示队列已满。
size值为0表示队列为空。

2、使用一个boolean类型的成员变量flag进行标记，初始值为false。

每次入队时将flag的值置为true，出队将flag的值置为false，
当rear == front && flag == true表示队列已满。
当rear == front && flag == false表示队列为空。

3、浪费一个空间。

每次存放元素之前都先检查一下rear的下一个下标与 front 是否相等（也可以使用格式进行判断：（rear+1）% array.length 是否与 front 相等），
如果rear的下一个下标与 front 相等则表示队列已满。
如果rear == front则表示队列为空。

🧊模拟实现循环队列

🚀LeetCode -- 设计循环队列

📌题目描述

设计你的循环队列实现。循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

MyCircularQueue(k): 构造器，设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空，返回 -1 。
Rear: 获取队尾元素。如果队列为空，返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。

📋题目示例

MyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3
circularQueue.enQueue(1);  // 返回 true
circularQueue.enQueue(2);  // 返回 true
circularQueue.enQueue(3);  // 返回 true
circularQueue.enQueue(4);  // 返回 false，队列已满
circularQueue.Rear();  // 返回 3
circularQueue.isFull();  // 返回 true
circularQueue.deQueue();  // 返回 true
circularQueue.enQueue(4);  // 返回 true
circularQueue.Rear();  // 返回 4

💥注意：

同理在出队时，front 也会出现这种情况，所以使用方式：front = (front+1)%elem.length;

🌊代码示例

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

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

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

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

    /**
     * 得到队头元素
     * @return
     */
    public int Front() {
        if(isEmpty()){
            //OJ上需要返回-1；自己写可以抛出一个异常
            return -1;
        }
        return this.elem[front];
    }

    /**
     * 得到队尾元素
     * @return
     */
    public int Rear() {
        if(isEmpty()){
            return -1;
        }
        if(rear==0){
            return elem[elem.length-1];
        }else{
            return elem[rear-1];
        }
    }

    /**
     * 判断队列是否为空
     * @return
     */
    public boolean isEmpty() {
       return front == rear;
    }

    /**
     * 判断队列是否满了
     * @return
     */
    public boolean isFull() {
        //如果rear的下一个下标是front，表示队列已满
        if((rear+1)%elem.length == front){
            return true;
        }
        return false;
    }
}

四、双端队列(Deque)

🧊双端队列的介绍

双端队列（deque）是指允许两端都可以进行入队和出队操作的队列，deque 是 “double ended queue” 的简称。将队列的两端分别称为前端和后端，两端都可以入队和出队。
双端队列既能够当队列使用，也能当栈使用，Java底层是使用双链表(LinkedList)来实现双端队列(Deque)和队列(Queue)的。
限制一端进行出队或入队的双端队列称为受限的双端队列。

🧊双端队列的常用方法

五、队列练习题

🚀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

⏳解题思路

栈：先进后出
队列：先进先出
创建两个队列，分别为队列1、队列2。无论出栈还是入栈都操作的是不为空的队列
元素入栈时，将元素存放到不为空的队列中。一开始两个队列都为空，那么就指定其中一个队列进行入队操作。
元素出栈时，找到不为空的队列，将队列中size-1个元素先转移到另一个队列中（转移：通过遍历队列，将出队的每一个元素先存放到一个变量中，再将该变量插入到另外一个队列中），剩下的一个元素就是要出栈的元素，所以将剩下的一个进行出队操作。
获取栈顶元素时，将队列中size个元素先转移到另一个队列中，返回保存转移元素的变量。（最终保存的是队列的最后一个元素，即为栈顶元素）。

🌊代码示例

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

    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }
    
    public void push(int x) {
        if(!queue1.isEmpty()){
            queue1.offer(x);
        }else if(!queue2.isEmpty()){
            queue2.offer(x);
        }else{
            queue1.offer(x);
        }
    }
    
    public int pop() {
        if(empty()){
            return -1;
        }
        if(!queue1.isEmpty()){
            int size = queue1.size();
            for(int i=0;i<size-1;i++){
                int value = queue1.poll();
                queue2.offer(value);
            }
            return queue1.poll();
        }
        if(!queue2.isEmpty()){
            int size = queue2.size();
            for(int i=0;i<size-1;i++){
                int value = queue2.poll();
                queue1.offer(value);
            }
            return queue2.poll();
        }
        return -1;
    }
    
    public int top() {
        if(empty()){
            return -1;
        }
        int value = -1;
        if(!queue1.isEmpty()){
            int size = queue1.size();
            for(int i=0;i<size;i++){
                value = queue1.poll();
                queue2.offer(value);
            }
            return value;
        }
        if(!queue2.isEmpty()){
            int size = queue2.size();
            for(int i=0;i<size;i++){
                value = queue2.poll();
                queue1.offer(value);
            }
            return value;
        }
        return -1;
    }
    
    public boolean empty() {
        return queue1.isEmpty() && queue2.isEmpty();
    }
}

🚀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（双端队列）来模拟一个栈，只要是标准的栈操作即可。

📋题目示例

输入：
["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、栈2。
入队：将所有元素都存放到栈1里面
出队：出队操作对栈2进行出栈，如果栈2为空，那么就把栈1里面的所有元素都放到栈2中。
从栈1进，从栈2出。这样可以满足队列先进先出的特点。
当两个栈都为空时，表示队列为空。

🌊代码示例

class MyQueue {
    Stack<Integer> stck1;
    Stack<Integer> stck2;
    public MyQueue() {
        stck1 = new Stack<>();
        stck2 = new Stack<>();
    }
    
    public void push(int x) {
        stck1.push(x);
    }
    
    public int pop() {
        if(empty()) return -1;
        if(!stck1.empty() && stck2.empty()){
            int size = stck1.size();
            int val = -1;
            for(int i=0;i<size;i++){
                val = stck1.pop();
                stck2.push(val);
            }
        }
        return stck2.pop();
    }
    
    public int peek() {
        if(empty()) return -1;
        if(!stck1.empty() && stck2.empty()){
            int size = stck1.size();
            int val = -1;
            for(int i=0;i<size;i++){
                val = stck1.pop();
                stck2.push(val);
            }
        }
        return stck2.peek();
    }
    
    public boolean empty() {
        return stck2.empty() && stck1.empty();
    }
}

潇湘夜雨.

关注

9
点赞
踩
12

收藏

觉得还不错? 一键收藏
打赏
7
评论
【Java---数据结构】队列

一、概念队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表。队列具有先进先出FIFO(FirstIn First Out) 入队列：进行插入操作的一端称为队尾（Tail/Rear）出队列：进行删除操作的一端称为队头特点：先进先出...
复制链接

扫一扫