队列的实现及相关OJ题

点进来你就是我的人了
博主主页：戳一戳,欢迎大佬指点!
人生格言：当你的才华撑不起你的野心的时候,你就应该静下心来学习!

欢迎志同道合的朋友一起加油喔
目标梦想：进大厂，立志成为一个牛掰的Java程序猿，虽然现在还是一个嘿嘿
谢谢你这么帅气美丽还给我点赞！比个心

---

目录

一、队列的基本概念

1.什么是队列

2.普通队列和双端队列

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

4. 单向链表实现队列

5. 双向链表实现队列

6.循环队列

二、队列相关OJ题

1.设计循环队列

2.  用栈实现队列​编辑​

3. 用队列实现栈

---

---

一、队列的基本概念

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 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 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 queue = new ArrayDeque<>();//顺序队列

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

Queue 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）

         ● 解题思路:结合上面循环队列讲解和下图理解

​

          ● 实现代码:

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;
        this.elem[rear]=value;
        rear=(this.rear+1)%elem.length;
        return true;
    }

    //出队操作
    public boolean deQueue() {
        if(isEmpty()) return 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;
        }else{index=rear-1;}
        return this.elem[index];
    }
 
    public boolean isEmpty() {
     return front==rear;
    }
 
    public boolean isFull() {
    //判断rear下一个是front就是满了
    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 s1; //入队列
    Deque s2; //出队列
 
    public MyQueue() {
       s1 = new ArrayDeque();
       s2 = new ArrayDeque();
    }
    
    public void push(int x) {
       s1.push(x);
    }
    
    public int pop() {
        if(s2.isEmpty() && !s1.isEmpty()) {
            while(!s1.isEmpty()) {
                s2.push(s1.pop());
            }
            return s2.pop();
        }else {
            return s2.pop();
        }
    }
    
    public int peek() {
        if(s2.isEmpty() && !s1.isEmpty()) {
            while(!s1.isEmpty()) {
                s2.push(s1.pop());
            }
            return s2.peek();
        }else {
            return s2.peek();
        }
    }
    
    public boolean empty() {
       return s1.isEmpty() && s2.isEmpty(); 
    }
}

3. 用队列实现栈

​

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

        ● 写题思路：

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

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

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

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

        ● 图示 

       ● 实现代码:

class MyStack {
    Queue q1;
    Queue 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(!q1.isEmpty()) {
           int length = q1.size();
           for(int i = 0;i < length - 1;i++) {
               q2.offer(q1.remove());
           }           
           return q1.remove();
       }else {
           int length = q2.size();
           for(int i = 0;i < length - 1;i++) {
               q1.offer(q2.remove());
           }
           return q2.remove();
       }
    }
    
    public int top() {
        if(!q1.isEmpty()) {
           int length = q1.size();
           for(int i = 0;i < length - 1;i++) {
               q2.offer(q1.remove());
           }
           int x = q1.peek(); //得到栈顶元素值
           q2.offer(q1.remove());//将栈顶元素移动到另一个队列
           return x;
       }else {
           int length = q2.size();
           for(int i = 0;i < length - 1;i++) {
               q1.offer(q2.poll());
           }
           int x = q2.peek();
           q1.offer(q2.remove());
           return x;
       }
    }
    
    public boolean empty() {
        if(q1.isEmpty()  && q2.isEmpty()) return true; //两个队列为空则为空
        else return false;
    }
}

​