用链表实现队列

用单链表实现队列

package SingleLinkedListQueue;

import LoopQueue.Queue;

/*
 * 用链表实现队列 ，然后和数组实现队列比较一下时间复杂度
 */
public class LinkedListQueue<E> implements Queue<E>{
	private class Node{
//		声明两个成员变量：数据e，下一个节点next
		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();
			}	
	}
//   定义头节点、尾节点和size
	private Node head,tail;
	private int size;
	public LinkedListQueue(LinkedListQueue<E>.Node head, LinkedListQueue<E>.Node tail, int size) {
		this.head = null;
		this.tail = null;
		this.size = 0;
	}
	public LinkedListQueue() {
		this(null,null,0);
		// TODO Auto-generated constructor stub
	}
	@Override
	public void enqueue(E e) {
		// TODO Auto-generated method stub
//     带插入节点
		 Node node =new Node(e);
//      入队时需要分类讨论下：如果队列为空
		 if(tail==null) {
			 tail=node;
			 head=tail;
		 }
//       队列不为空时
		 else {
			 tail.next=node;
			 tail=node;
		 }
		 size++;
	}
	@Override
	public E dequeue() {
		// TODO Auto-generated method stub
		if(isEmpty()) {
			throw new IllegalArgumentException("dequeue failed,queue is empty");
		}
//       出队的节点为队首这个节点
		Node delnode =head;
		head =delnode.next; //更新一下头部
		delnode.next =null;
		size--;
		if(isEmpty()) {
			tail =null;
		}
		return delnode.e;
	}
	@Override
	public E getFront() {
		// TODO Auto-generated method stub
		if(isEmpty()){
			throw new IllegalArgumentException("getFront failed,queue is empty");
		}
		return head.e;
	}
	@Override
	public E getRear() {
		// TODO Auto-generated method stub
		return null;
	}
	@Override
	public int getSize() {
		// TODO Auto-generated method stub
		return size;
	}
	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		return size==0;
	}
	@Override
	public String toString() {
		StringBuilder res=new StringBuilder();
		res.append("queue=head:");
		Node cur =head;
		while(cur!=null) {
			res.append(cur+"->");
			cur=cur.next; 
			
		}
		res.append("null tail");
		return res.toString();
	}
	
	
}

测试：

package SingleLinkedListQueue;

import java.util.Random;

import LoopQueue.LoopQueue;
import LoopQueue.Queue;

public class LinkedListQueueTest {
public static void main(String[] args) {
	LinkedListQueue e =new LinkedListQueue<Integer>();
	for(int i=0;i<5;i++) {
		e.enqueue(i);
	}
	System.out.println(e);
	for(int i=0;i<5;i++) {
		e.dequeue();
	}
	System.out.println(e);
	System.out.println(e.getSize());
	 
	int opCount = 100000;
	LinkedListQueue<Integer> loopQueue = new LinkedListQueue<>();
    double time2 = testListQueue(loopQueue, opCount);
    System.out.println("ListQueue, time: " + time2 + " s");
    
}
private static double testListQueue(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;
}
}

测试结果：