链表队列及其与数组队列的比较

//添加元素是从列表尾部tail，删除元素从链表头部head
public class LinkedListQueue<E> implements Queue<E> {
    private class Node{
        public E e;
        public Node next;

        public Node(E e, Node next){
            this.e = e;
            this.next = next;
        }

        public Node(E e){this(e,null);}

        public Node(){this(null);}

        @Override
        public String toString(){return e.toString();}
    }

    private  Node head,tail;
    private int size;

    public LinkedListQueue(){
        head=null;
        tail=null;
        size=0;
    }

    @Override
    public int getSize(){
        return size;
    }

    @Override
    public boolean isEmpty(){
        return size==0;
    }

    @Override
    public void enqueue(E e){
        if(tail==null){
            tail=new Node(e);
            head=tail;
        }
        else{
            tail.next=new Node(e);
            tail=tail.next;
        }
        size++;
    }

    @Override
    public E dequeue() {
        if (isEmpty())
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
        Node retNode=head;
        head=head.next;
        retNode.next=null;
        if(head==null)
            tail=null;
        size--;
        return retNode.e;
    }

    @Override
    public E getFront(){
        if(isEmpty())
            throw new IllegalArgumentException("Queue is empty.");
        return head.e;
    }

    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append("Queue: front ");

        Node cur = head;
        while(cur != null) {
            res.append(cur + "->");
            cur = cur.next;
        }
        res.append("NULL tail");
        return res.toString();
    }
 }

测试：

public static void main(String[] args) {
    LinkedListQueue<Integer> queue = new LinkedListQueue<>();
    for(int i=0;i<10;i++){
        queue.enqueue(i);
        System.out.println(queue);

        if(i%3==2){
            queue.dequeue();
            System.out.println(queue);
        }
    }
}

结果：

比较：

import java.util.Random;

public class Main {
    //测试使用q运行opCount个enqueue和dequeue操作所需要的时间，单位:秒
    private static double testQueue(Queue<Integer> q,int opCount){
        long starttime=System.nanoTime();
        Random random=new Random();
        for(int i=0;i<opCount;i++)
            q.enqueue(random.nextInt(Integer.MAX_VALUE));
        for(int i=0;i<opCount;i++)
            q.dequeue();
        long endtime=System.nanoTime();

        return (endtime-starttime)/1000000000.0;
    }
    public static void main(String[] args) {
        int opCount=100000;
        ArrayQueue<Integer> arrayQueue=new ArrayQueue<>();
        double time1=testQueue(arrayQueue,opCount);
        System.out.println("ArrayQueue,time:"+time1+"s");

        LoopQueue<Integer> loopQueue = new LoopQueue<>();
        double time2=testQueue(loopQueue,opCount);
        System.out.println("LoopQueue,time:"+time2+"s");

        LinkedListQueue<Integer> lindedListQueue = new LinkedListQueue<>();
        double time3=testQueue(lindedListQueue,opCount);
        System.out.println("LinkedListQueue,time:"+time3+"s");
    }
}

结果：