Java顺序队列、链式队列、循环队列

//顺序队列
package com.queue;

public class ArrayQueue {
    private int n;
    private int[] arr;
    private int head = 0;
    private int tail = 0;

    public ArrayQueue(int capacity){
        this.n = capacity;
        arr = new int[capacity];
    }

    public Boolean enqueue(int data){
        if(tail == n) return false;
        arr[tail++] = data;
        return true;
    }
    public Integer dequeue(){
        if(head == tail) return null;
        int temp = arr[head--];
        return temp;
    }

    public void myprint(){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }

    //当队列的 tail 指针移动到数组的最右边后，如果有新的数据入队，我
    //们可以将 head 到 tail 之间的数据，整体搬移到数组中 0 到 tail-head 的位置。
    public Boolean enqueue2(int data){
        if(tail == n)
        {
            if(head == 0) return false;
            //进行移动
            for(int i = head;i<tail;i++)
            {
                arr[i-head] = arr[i];
            }
            head =0;
            tail = tail-head;
        }
        //入队
        arr[tail++] = data;
        return true;
    }
}

//链式队列
package com.queue;

public class LinkQueue {
    static class Node {
        private Object data;
        private Node next;
    }

    private Node head = new  Node();
    private Node tail = head;

    public Boolean enqueue(Object data){
        Node newNode = new Node();
        newNode.data = data;
        if(head==tail)
            head.next = newNode;
        else
            tail.next = newNode;
        tail = newNode;
        return true;
    }

    public Object dequeue(){
        if(head==tail) return null;
        Object data = head.next.data;
        head.next = head.next.next;
        return data;
    }

    public void myprint(){
        Node p = new Node();
        p = head.next;
        while(p!=null)
        {
            System.out.print(p.data+" ");
            p = p.next;
        }
    }

}

//循环队列
package com.queue;

public class CirculQueue {
    private Object arr[];
    private int n;
    private int head = 0;
    private int tail = 0;

    public CirculQueue(int capacity){
        this.n = capacity;
        arr = new Object[n];
    }

    public Boolean Enqueue(Object data){
        if((tail+1)% n==head) return false;
        arr[tail] = data;
        tail = (tail+1)%n;
        return true;
    }

    public Object Dequeue(){
        if(head == tail) return null;
        Object temp = arr[head++];
        head = (head + 1) % n;
        return temp;
    }

}