【Java 数据结构】队列的实现及相关OJ题

书生－w

已于 2023-04-29 06:46:29 修改

阅读量1.6w

点赞数 2

分类专栏：数据结构文章标签： java 开发语言

于 2023-04-17 09:15:27 首次发布

本文链接：https://blog.csdn.net/m0_53882348/article/details/130191499

版权

数据结构专栏收录该内容

18 篇文章 5 订阅

订阅专栏

🎉🎉🎉点进来你就是我的人了
博主主页：🙈🙈🙈戳一戳,欢迎大佬指点!

欢迎志同道合的朋友一起加油喔🦾🦾🦾

一、队列的基本概念

1.什么是队列

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

2.普通队列和双端队列

3.关于队列一些操作的实现

①普通队列

Queue(一般多使用返回特殊值的处理，更加方便）

错误处理	抛出异常	返回特殊值
入队列	add(e)	offer(e)
出队列	remove()	poll()
队首元素	element()	peak(）

方法简单演示:

public class Test {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(1);
        queue.offer(2);
        System.out.println("该队列队头元素为：");
        System.out.println(queue.peek());
        System.out.println("出队元素为");
        System.out.println(queue.poll());
    }
}

②双端队列

Deque(一般多使用返回特殊值的处理，更加方便）

头部/尾部	头部元素(队首)		尾部元素(队尾)
错误处理	抛出异常	返回特殊值	抛出异常	返回特殊值
入队列	addFirst(e)	offerFirst(e)	addLast(e)	offerLast(e)
出队列	removeFirst()	pollFirst()	removeLast()	pollLast()
获取元素	getFirst()	peekFirst()	getLast()	peekLast()

方法简单演示:

import java.util.*;
 
public class Test {
    public static void main(String[] args) {
        Deque<Integer> queue = new LinkedList<>();
      queue.offerFirst(2);
      queue.offerLast(1);
        System.out.println("该队列队头元素为：");
        System.out.println(queue.peek());
        System.out.println("出队元素为");
       System.out.println(queue.poll());
    }
}

● 顺序队：Queue接口+实现类ArrayDeque

Queue<Integer> queue = new ArrayDeque<>();//顺序队列

● 链式队：Queue接口+实现类LinkedList

Queue<Integer> queue2 = new LinkedList<>();//链式队列

4. 单向链表实现队列

● 实现代码:

class Node{
    public int val;
    public Node next;
    public int usedSize;
    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;
        }
        usedSize++;
    }

    //出队
    public int poll(){
        if(isEmpty()){
            throw new RuntimeException("队列为空！");
        }
        int oldVal=head.val;
        this.head=head.next;
        if(head == null) {
            last null;
        }
        usedSize--;
        return oldVal;
    }
    
    //是否为空
    public boolean isEmpty(){
        return this.usedSize == 0;
    }

    //查看栈顶元素
    public int peek( ){
        if(isEmpty()) {
            throw new RuntimeException("队列为空！");
        }
        return head.val;
    }
    public int getUsedSize() {
        return usedSize;
    }
}

5. 双向链表实现队列

public class Queue {
    // 双向链表节点
    public static class ListNode {
        ListNode next;
        ListNode prev;
        int value;

        ListNode(int value) {
            this.value = value;
    }

    ListNode first; // 队头
    ListNode last; // 队尾
    int size = 0;

    // 入队列---向双向链表位置插入新节点
    public void offer(int e) {
        ListNode newNode = new ListNode(e);
        if (first == null) {
            first = newNode;
        // last = newNode;
        } else {
            last.next = newNode;
            newNode.prev = last;
        // last = newNode;
        }
        last = newNode;
        size++;
    }

    // 出队列---将双向链表第一个节点删除掉
    public int poll() {
        // 1. 队列为空
        // 2. 队列中只有一个元素----链表中只有一个节点---直接删除
        // 3. 队列中有多个元素---链表中有多个节点----将第一个节点删除
        int value = 0;
        if (first == null) {
            return -1;
        } else if (first == last) {
            last = null;
            first = null;
        } else {
            value = first.value;
            first = first.next;
            first.prev.next = null;
            first.prev = null;
        }
        --size;
        return value;
    }

    // 获取队头元素---获取链表中第一个节点的值域
    public int peek() {
        if (first == null) {
            return -1;
        }
        return first.value;
    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return first == null;
    }
}

6.循环队列

循环队列的引入:

二、队列相关OJ题

1.设计循环队列

● 写题链接:225. 用队列实现栈 - 力扣（LeetCode）

● 解题思路:front代表队头元素的下标,rear代码队尾元素的下标,每次入队出队都用取模公式来维护,入队元素增加,队尾rear下标的位置更新到(rear+1) % elem.length位置上,出队元素减少,队头front下标的位置也更新到(rear+1) % elem.length位置上,注意获取队尾元素的时候,如果rear==0说明队尾元素已经走到该数组的最后一个位置了,因为我们底层是用数组维护的,防止越界.

注意:

在循环队列中，我们添加元素时，元素被放置在队尾指针 rear 当前的位置，然后 rear 会向后移动一步。所以，真正的元素存储在 rear - 1 的位置上（当 rear 为 0 时，元素存储在数组的末尾位置）。这意味着，在任何时刻，rear 所指向的位置都是空的。

当 rear 的下一个位置就是队头指针 front 时，说明队列已经满了。这时，我们不能再向队列中添加元素，因为这将使得队头指针和队尾指针指向同一位置，导致队列为空和队列已满的歧义。所以，在这种情况下，我们不会在当前 rear 所指向的位置放置元素，保持这个位置为空，以区分队列为空和队列已满的状态。

● 实现代码:

class MyCircularQueue {

    public int[] elem; // 存储队列元素的数组
    public int front; // 队头下标
    public int rear; // 队尾下标

    public MyCircularQueue(int k) {
        // 因为牺牲了一个空间,所以数组长度+1
        this.elem = new int[k + 1];
    }

    // 入队操作
    public boolean enQueue(int value) {
        if (isFull()) return false; // 如果队列已满, 直接返回 false
        this.elem[rear] = value; // 将值放入队尾位置
        rear = (this.rear + 1) % elem.length; // 更新队尾下标，使用取模运算实现循环
        return true;
    }

    // 出队操作
    public boolean deQueue() {
        if (isEmpty()) return false; // 如果队列为空, 直接返回 false
        // 不用管原数，会被新入队的数直接替代
        front = (this.front + 1) % elem.length; // 更新队头下标，使用取模运算实现循环
        return true;
    }

    // 得到队头元素
    public int Front() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空"); // OJ上改为 return -1;
        }
        return this.elem[front]; // 返回队头元素
    }

    // 得到队尾元素
    public int Rear() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空"); // OJ上改为 return -1;
        }
        int index = 0;
        if (rear == 0) {
            index = elem.length - 1; // 当队尾下标为0时,队尾元素位于数组末尾
        } else {
            index = rear - 1; // 其他情况下,队尾元素位于队尾下标前一个位置
        }
        return this.elem[index]; // 返回队尾元素
    }

    // 判断队列是否为空
    public boolean isEmpty() {
        return front == rear; // 队头下标等于队尾下标时, 队列为空
    }

    // 判断队列是否已满
    public boolean isFull() {
        // 判断队尾下一个位置是队头就是满了
        if ((this.rear + 1) % elem.length == front) {
            return true;
        }
        return false;
    }
}

2. 用栈实现队列

● 写题链接:232. 用栈实现队列 - 力扣（LeetCode）

● 写题思路：

1) 因为队列是先进先出，所以我们要借用两个栈实现

2) 一个栈A存入队的序列，另一个栈B为出队的序列，栈B的数据由栈A出栈得到

3) 出数据从栈B出，如果栈B为空则从栈A中获取，再由栈B出数据，实现数据的先进先出。

● 图示

● 实现代码:

class MyQueue {
    Deque<Integer> s1; // 入队栈
    Deque<Integer> s2; // 出队栈

    public MyQueue() {
        s1 = new ArrayDeque<Integer>(); // 初始化入队栈
        s2 = new ArrayDeque<Integer>(); // 初始化出队栈
    }

    public void push(int x) {
        s1.push(x); // 将元素推入入队栈
    }

    public int pop() {
        if (empty()) { // 如果队列为空
            return -1;
        }
        if (s2.isEmpty() && !s1.isEmpty()) { // 如果出队栈为空且入队栈非空
            while (!s1.isEmpty()) { // 将入队栈的所有元素倒入出队栈
                s2.push(s1.pop());
            }
            return s2.pop(); // 弹出出队栈顶部元素
        }
        return s2.pop(); // 弹出出队栈顶部元素
    }

    public int peek() {
        if (empty()) { // 如果队列为空
            return -1;
        }
        if (s2.isEmpty() && !s1.isEmpty()) { // 如果出队栈为空且入队栈非空
            while (!s1.isEmpty()) { // 将入队栈的所有元素倒入出队栈
                s2.push(s1.pop());
            }
            return s2.peek(); // 返回出队栈顶部元素，但不弹出
        }
        return s2.peek(); // 返回出队栈顶部元素，但不弹出
    }

    public boolean empty() {
        return s1.isEmpty() && s2.isEmpty(); // 当入队栈和出队栈都为空时，队列为空
    }
}

3. 用队列实现栈

● 写题链接:225. 用队列实现栈 - 力扣（LeetCode）

● 写题思路：

1) 因为栈是先进后出，所以我们要借用两个队列实现

2) 哪个队列不为空则往那个队列入数据，如果都为空，默认往队列qu1入数据

3) 出数据时要先将数据不为空的队列的前length - 1个元素入到另一个空队中，然后将最后一个元素出队。

注:查看栈顶元素不需要将最后一个元素出队，要保存它，且继续把它入到另一个空队中。

● 图示

● 实现代码:

class MyStack {
    Queue<Integer> q1; // 第一个队列
    Queue<Integer> q2; // 第二个队列

    public MyStack() {
        q1 = new LinkedList(); // 初始化第一个队列
        q2 = new LinkedList(); // 初始化第二个队列
    }

    public void push(int x) {
        if (!q1.isEmpty()) { // 如果第一个队列非空
            q1.offer(x); // 将元素添加到第一个队列末尾
        } else if (!q2.isEmpty()) { // 如果第二个队列非空
            q2.offer(x); // 将元素添加到第二个队列末尾
        } else {
            if (q1.isEmpty() && q2.isEmpty()) { // 如果两个队列都为空
                q1.offer(x); // 将元素添加到第一个队列末尾
            }
        }
    }

    public int pop() {
        if (empty()) { // 如果栈为空
            return -1;
        }
        if (!q1.isEmpty()) { // 如果第一个队列非空
            int size = q1.size();
            for (int i = 0; i < size - 1; i++) { // 将前 size-1 个元素移动到第二个队列
                int val = q1.poll();
                q2.offer(val);
            }
            return q1.poll(); // 返回并移除第一个队列的最后一个元素
        } else {
            int size = q2.size();
            for (int i = 0; i < size - 1; i++) { // 将前 size-1 个元素移动到第一个队列
                int val = q2.poll();
                q1.offer(val);
            }
            return q2.poll(); // 返回并移除第二个队列的最后一个元素
        }
    }

    public int top() {
        if (empty()) { // 如果栈为空
            return -1;
        }
        if (!q1.isEmpty()) { // 如果第一个队列非空
            int size = q1.size();
            int val = -1;
            for (int i = 0; i < size; i++) { // 将所有元素移动到第二个队列，同时记录最后一个元素的值
                val = q1.poll();
                q2.offer(val);

            }
            return val; // 返回最后一个元素的值，即栈顶元素
        } else {
            int size = q2.size();
            int val = -1;
            for (int i = 0; i < size; i++) { // 将所有元素移动到第一个队列，同时记录最后一个元素的值
                val = q2.poll();
                q1.offer(val);
            }
            return val; // 返回最后一个元素的值，即栈顶元素
        }
    }

    public boolean empty() {
        if (q1.isEmpty() && q2.isEmpty()) { // 如果两个队列都为空
            return true; // 栈为空
        } else {
            return false; // 栈非空
        }
    }
}

书生－w

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
2
评论
【Java 数据结构】队列的实现及相关OJ题

一、队列的基本概念1.什么是队列只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾（Tail/Rear）出队列：进行删除操作的一端称为队头（Head/Front）2.普通队列和双端队列3.关于队列一些操作的实现①普通队列Queue(一般多使用返回特殊值的处理，更加方便）错误处理抛出异常返回特殊值入队列add(e)offer(e)出队列remove()poll()
复制链接

扫一扫