数据结构与算法之队列

　　队列中典型的就是遵循先进先出原则的，队列是操作受限制的线性表结构。

 一、队列的特点

队列最大的特点就是先进先出，主要有两个操作入列和出列。
跟栈一样，既可以用数组实现，又可以用链表实现，用数组实现叫顺序队列，用链表实现，叫链式队列，特别是一个长的像环的循环队列。
在数组实现队列的时候，会有数据搬移操作，要想解决数据搬移的问题，我们就需要像环一样的循环队列。

二、基于数组实现的队列

public class ArrayQueue {

    // 数组：items 数组的大小：n
    private String[] items;

    private int n = 0;

    // head表示对头下标 tail表示队尾下标
    private int head = 0;

    private int tail = 0;

    /**
     * 申请一个大小为capacity的数组
     * 
     * @param capacity
     */
    public ArrayQueue(int capacity) {
        this.items = new String[capacity];
        this.n = capacity;
    }

    /**
     * 入列操作
     * 
     * @param item
     * @return
     */
    public boolean enqueue(String item) {
        // 如果tail == n 表示队列满了
        if (tail == n) {
            return false;
        }
        this.items[tail] = item;
        ++tail;
        return true;
    }

    /**
     * 出列操作
     * 
     * @return
     */
    public String dequeue() {
        // 如果 head == tail 表示队列为空
        if (this.head == this.tail) {
            return null;
        }
        String ret = this.items[head];
        ++head;
        return ret;
    }

    /**
     * 随着不停的入列，出列操作，当tail移动到最后一个数组位置的时候，即使数组中前面还有空余空间也无法在队列中添加数据了，解决这个问题的
     * 办法是进行数据搬移，将队列后面的数据搬移到前面空余的位置中，改造入队操作，若空间不足，触发数据搬移
     * 
     */

    /**
     * 改造之后的入列操作
     * 
     * @param item
     * @return
     */
    public boolean enqueue2(String item) {
        // tail == n 表示队列中没有剩余空间了
        if (tail == n) {
            // tail == n && head == 0表示整个队列都占满了
            if (head == 0) {
                return false;
            }
            // 数据搬移
            for (int i = head; head < tail; ++i) {
                this.items[i - head] = this.items[i];
            }
            // 搬移之后重新更新 head tail 向前移动了head距离
            tail -= head;
            head = 0;
        }
        this.items[tail] = item;
        ++tail;
        return true;
    }

}

三、基于链表实现的队列

public class QueueBasedOnLinkedList {

    //队列的队首 和 队尾
    private Node head = null;
    private Node tail = null;
    
    /**
     * 入列操作
     * 
     * @param value
     */
    public void enqueue(String value){
        if(tail == null){
            Node newNode = new Node(value, null);
            head = newNode;
            tail = newNode;
        }else{
            tail = new Node(value, null);
            tail.next = tail;
        }
    }
    
    /**
     * 出列操作
     * 
     * @return
     */
    public String dequeue(){
        if(head == null){
            return null;
        }
        String value = head.data;
        head = head.next;
        if(head == null){
            tail = null;
        }
        return value;
    }
    
    public void printAll(Node node){
        while(node != null){
            System.out.print(node.data + " ");
            node = node.next;
        }
        System.out.println();
    }
    
    public static class Node{
        private String data;
        private Node next;
        
        public Node(String data, Node next){
            this.data = data;
            this.next = next;
        }
        
        public String getData(){
            return this.data;
        }
    }
}

四、环形队列

public class CircularQueue {

    // 数组：items 数组长度：n
    private String[] items;
    private int n = 0;

    // head 表示对头下标 tail表示队尾下标
    private int head = 0;
    private int tail = 0;

    /**
     * 申请一个大小为capacity 的数组
     * 
     * @param capacity
     */
    public CircularQueue(int capacity) {
        this.items = new String[capacity];
        this.n = capacity;
    }

    /**
     * 入列操作
     * 
     * @return
     */
    public boolean enqueue(String item) {
        // 队列满了
        if ((tail + 1) % n == head) {
            return false;
        }
        this.items[tail] = item;
        tail = (tail + 1) % n;
        return true;
    }

    /**
     * 出列操作
     * 
     * @return
     */
    public String dequeue() {
        // 如果head = tail 表示队列为空
        if (head == tail) {
            return null;
        }
        String ret = items[head];
        head = (head + 1) % n;
        return ret;
    }
    
}

此大部分内容来自极客时间专栏，王争老师的《数据结构与算法之美》

极客时间：https://time.geekbang.org/column/intro/126