十四 链表队列

链表实现队列：

 

链表队列的实现：

    package com.lt.datastructure.Queue;
    
    
    
    public class LinkedListQueue<E> implements Queue<E>{    
        public 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,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;
        }
        
        /*
         * 入队 
         * 如果tail尾结点是空,新建第一个结点，head和tail指向此结点
         * 如果tail不为空,在tail的下一个位置新建结点,当作尾结点
         */
        @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 a Empty queue.");
            }
            //retNode指向head
            Node retNode = head;
            //head后移，为删除做准备
            head = head.next;
            //删除retNode
            retNode.next = null;
            
            //如果只有一个结点，删除之后让tail为空
            if(head == null) {
                tail =null;
            }
            size --;
            
            return retNode.e;
        }
        
        @Override
        public E getFront(E e) {
            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");
            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);        
                }
            }
            
        }
        
    }

 

测试：

 

复杂度测试：

 

package com.lt.datastructure.Queue;

import java.util.Random;

    public class Main {
         /*
         * 测试ArrayQueue和LoopQueue
         */
        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<>();
      System.out.println("ArrayQueue:"+testQueue(arrayQueue,opCount));
      
      
      LoopQueue<Integer> loopQueue = new LoopQueue<>();
      System.out.println("LoopQueue:"+testQueue(loopQueue, opCount));
      
      LinkedListQueue<Integer> linkedListQueue = new LinkedListQueue<>();
      System.out.println("LinkedListQueue:"+testQueue(linkedListQueue, opCount));
   }
}

三种队列分别所需时间：