队列（Queue）

一.概念

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

 

二，队列的使用

在Java中，队列是一个接口，底层是用双向链表实现的 

• Boolean  offer（E e）            入队列
• E poll                                      出队列
• peek                                        获取队头元素
• int size                                     队列有效元素个数
• Boolean   isEmpty                    队列是否为空  

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

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

public class Test {
    public static void main(String[] args) {
        Queue<Integer> qu = new LinkedList<>();
        qu.offer(10);
        qu.offer(20);
        qu.offer(30);
        qu.offer(40);
        qu.offer(50);
        qu.offer(60);

        System.out.println(qu.size());
        System.out.println(qu.peek());
        System.out.println(qu.poll());

        System.out.println(qu.peek());
        System.out.println(qu.size());

        qu.poll();
        qu.poll();
        qu.poll();
        qu.poll();
        qu.poll();

        if (qu.isEmpty()){
            System.out.println("队列为空！");
        }else{
            System.out.println("队列不为空！");
        }
    }
}

 三，循环队列

 关于循环队列：

• 他解决了，假溢出问题，可以对空间进行循环利用
• 通常用数组实现
• 如何区分循环队列空与满

1.  通过添加 size 属性记录
2. 保留一个位置
3. 使用标记

四，模拟实现Queue 

//模拟实现队列 --- 底层使用的双向链表----在集合中Queue是一个接口
public class Queue<E> {

    public static class ListNode<E>{
        ListNode<E> next;
        ListNode<E> prev;

        E value;

        public ListNode(E value){
            this.value = value;
        }
    }

    ListNode<E> first;
    ListNode<E> last;
    int size;

    //入队列
    public void offer(E e){
        ListNode<E> newNode = new ListNode<>(e);

        //队列为空的情况
        if (first == null){
            first = newNode;
        }else{
            //队列不为空
            newNode.prev = last;
            last.next = newNode;
        }
        last = newNode;
        size++;
    }

    //出队列
    public void poll(){
        E value = null;
        //队列为空
        if (first == null){
            throw new RuntimeException("队列为空，无法出队列！");
        }

        //队列只有一个元素
        if (last == first){
            value = first.value;
            first = null;
            last = null;
        }else {
            //队列有多个元素
            value = first.value;
            first = first.next;
            first.prev.next = null;
            first.prev = null;
        }
        size--;
        System.out.println(value);
    }

    //获取队头元素
    public void peek(){
        E value = null;
        //队列为空
        if (first == null){
            throw new RuntimeException("队列为空，无法获取队列的队头元素！");
        }else {
            //队列不为空
            System.out.println(first.value);
        }
    }

    //获取元素个数
    public void size(){
        System.out.println(size);
    }

    //判断是否为空
    public void isEmpty(){
        if (size == 0){
            System.out.println("队列为空！");
        }else{
            System.out.println("队列不为空！");
        }
    }

    public static void main(String[] args) {
        Queue<Integer> q = new Queue<>();

        q.isEmpty();     //  队列为空
        q.size();        //  0


        q.offer(1);
        q.offer(2);
        q.offer(3);
        q.offer(4);
        q.offer(5);

        q.poll();       //  1
        q.isEmpty();    //  队列不为空
        q.peek();       //  2
        q.size();       //  4

        q.poll();       //  2
        q.poll();
        q.poll();
        q.poll();      // 5

        q.isEmpty();    // 队列为空
        q.peek();      // 抛异常

    }
}