队列Queue【数据结构】

1.队列

1.1 概念

队列： 只允许在一端进行插入数据的操作，在另一端进行删除数据的操作的特殊线性表，队列具有“先进先出”的特性。
入队列：进行插入操作的一端称为队尾（tail）
出队列：进行删除操作的一端称为队头（head）

1.2 队列的使用

在java中，队列是个接口，底层通过链表实现的。

方法	功能
boolean offer(E e)	入队列
E poll()	出队列
peek()	获取队头元素
int size()	获取队列中有效元素的个数
boolean isEmpty()	检测队列是否为空

（1）创建队列

public class MyQueue {
    static  class Node{
        public int val;
        public Node next;
        public Node(int val){
            this.val = val;
        }
    }
    public Node head;//队列的头
    public Node tail;//队列的尾
}

（2）入队offer()

public void offer(int val){
        Node node = new Node(val);
        if(head == null){
            head = node;
            tail = node;
        }else{
            tail.next = node;
            tail = tail.next;
        }
    }

（3）出队poll()

    public int poll(){
        if(head == null){
            return -1;//或者抛异常
        }
        int oldVal = head.val;
        if(head.next == null){
            head = tail = null;
        }else{
            head = head.next;
        }
        return oldVal;
    }

（4）查看当前队头元素peek()

public int peek(){
        if(head == null){
            return -1;
        }
        return head.val;
    }

注意：Queue是个接口，在实例化时必须实例化LinkedList的对象，因为LinkedList实现了Queue接口。

public static void main(String[] args) {
        java.util.Queue<Integer> queue = new LinkedList<>();
        queue.offer(1);
        queue.offer(3);
        queue.offer(5);
        queue.offer(7);
        System.out.println(queue.size());
        System.out.println(queue.peek());
        queue.poll();
        System.out.println(queue.poll());
    }

运行结果：

1.3 循环队列

实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型时可以就会使用循环队列。环形队列通常使用数组实现

使用循环队列，就是将队列的首尾相连，这样rear移动到length时，就会再从0开始循环

1.那么如何区分队列的空与满，因为rear == front 时，即表示空也表示满

（1）最好的解决方法是计数法
（2）其次是浪费空间法（牺牲一个存储空间，front前面不存数据，当rear在front前面的时候就是满了）

（3）设置一个标志变量flag，当front == rear,且flag = 0 时为队列空，当front == rear，且flag = 1时为队列满。

例题：设计循环队列
链接622.设计循环队列 - 力扣(LeetCode)
设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

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

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

示例

分析：

代码：

class MyCircularQueue {
    public int[] elem;
    public int usedSize;
    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++; 千万不能加加 因为7不能到0
        rear = (rear+1)% elem.length;
        this.usedSize++;
        return true;
    }

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

    //3. 获取队头元素
    public int Front() {
        if (isEmpty()){
            return -1;
        }
        return elem[front];
    }

    //4. 获取队尾元素
    public int Rear() {
        if (isEmpty()){
            return -1;
        }
        int index = (rear == 0) ? elem.length - 1: rear - 1;
        return elem[index];
    }

//    public boolean  isEmpty1() {
//        return rear == front;
//    }
//
//    public boolean  isFull1() {
//        return (rear+1)% elem.length == front;
//    }
    public boolean  isEmpty() {
        return usedSize == 0;
    }

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

2.双端队列

双端队列（deque）是指允许两端都可以进行入队和出队操作的队列，那就说明元素可以从队头出队和入队，也可以从队尾出队和入队。

Deque是一个接口，使用时必须创建LinkedList的对象。

3.面试题

3.1 用队列实现栈

链接 225.用队列实现栈 - 力扣(LeetCode)

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作(push, pop, top,empty)
实现 MyStack 类：

• void push(int x) 将元素 x 压入栈顶。
• int pop() 移除并返回栈顶元素。
• int top() 返回栈顶元素。
• boolean empty() 如果栈是空的，返回 true ；否则，返回 false

示例：

分析：

代码：

package Demo01;


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

/**
 * 两个队列实现栈
 */
class MyStack {
    Queue<Integer> qu1;
    Queue<Integer> qu2;
    public int usedSize;
    public MyStack() {
        qu1 = new LinkedList<>();
        qu2 = new LinkedList<>();
    }
    //1.入栈
    public void push(int x) {
        if (!qu1.isEmpty()) {
            qu1.offer(x);
        }else if(!qu2.isEmpty()){
            qu2.offer(x);
        }else {
            qu1.offer(x);
        }
        usedSize++;
    }
    //2.出栈
    public int pop() {
        if (empty()){
            return -1;
        }
        if (!qu1.isEmpty()){
            int curSize = qu1.size();
            for(int i = 0; i < curSize-1; i++){
                qu2.offer(qu1.poll());
            }
            usedSize--;
            return qu1.poll();
        }else{
            int curSize = qu2.size();
            for(int i = 0; i < curSize-1; i++){
                qu1.offer(qu2.poll());
            }
            usedSize--;
            return qu2.poll();
        }
    }
    //3.获取栈顶元素
    public int top() {
        if (empty()){
            return -1;
        }
        if (!qu1.isEmpty()){
            int curSize = qu1.size();
            int ret = -1;
            for(int i = 0; i < curSize; i++){
                ret = qu1.poll();
                qu2.offer(ret);
            }
            return ret;
        }else{
            int curSize = qu2.size();
            int ret = -1;
            for(int i = 0; i < curSize; i++){
                ret = qu2.poll();
                qu1.offer(ret);
            }
            return ret;
        }
    }

    public boolean empty1() {
        return usedSize == 0;
    }
    public boolean empty() {
        return qu1.isEmpty() && qu2.isEmpty();
    }
};

3.2 用栈实现队列

链接232. 用栈实现队列 - 力扣(LeetCode)

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

• void push(int x) 将元素 x 推到队列的末尾
• int pop() 从队列的开头移除并返回元素
• int peek() 返回队列开头的元素
• boolean empty() 如果队列为空，返回 true ；否则，返回 false

分析：

代码：

package Demo;

import java.util.Stack;

class MyQueue {
    Stack<Integer> s1;
    Stack<Integer> s2;
    public MyQueue(){
        s1 = new Stack<>();
        s2 = new Stack<>();
    }
    public void push(int x){
        s1.push(x);
    }
    public int pop(){
        if(empty()){
            return -1;//当前队列为空
        }
        if (s2.empty()){
            //需要把s1里面的元素全部倒过来
            while (!s1.empty()){
                s2.push(s1.pop());
            }
        }
        //s2当中一定有元素
        return s2.pop();
    }
    public int peek(){
        if(empty()){
            return -1;//当前队列为空
        }
        if (s2.empty()){
            //需要把s1里面的元素全部倒过来
            while (!s1.empty()){
                s2.push(s1.pop());
            }
        }
        //s2当中一定有元素
        return s2.peek();
    }
    public boolean empty(){
        return s1.empty() && s2.empty();
    }
}

3.3 实现一个最小栈

链接155. 最小栈 - 力扣(LeetCode)

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

实现 MinStack 类:

• MinStack() 初始化堆栈对象。
• void push(int val) 将元素val推入堆栈。
• void pop()删除堆栈顶部的元素。
• int top() 获取堆栈顶部的元素。
• int getMin() 获取堆栈中的最小元素。

示例:

分析：


代码：

package Demo;

import java.util.Stack;

public class MinStack {

    private Stack<Integer> s;//普通栈
    private Stack<Integer> minStack;//当前栈的最小值

    public MinStack() {
         s = new Stack<>();
         minStack = new Stack<>();
    }

    //入栈
    public void push(int val) {
        s.push(val);//普通栈必须放
        if (minStack.empty()){
            //直接也存在最小栈一份
            minStack.push(val);
        }else{
            int peekV = minStack.peek();
            if (val <= peekV){
                minStack.push(val);
            }
        }
    }

    //出栈
    public void pop() {
        int popV = s.pop();
        int peekVMins = minStack.peek();
        if (popV == peekVMins){
            minStack.pop();
        }
    }

    public int top() {
        return s.peek();
    }

    public int getMin() {
        return minStack.peek();
    }
}