循环双链表之Java实现（模拟JDK中LinkedList）

单链表只有一个指针，仅仅指向当前结点的直接后继，为了弥补这个缺陷，故而引入双链表。

所谓双链表，就是每个Element都包含它本身存储的数据和两个指针，分别指向上一个和下一个Element，其结构如下：

我们可以很容易的写出表示链表结点的Java Code:

                private T value=null;//use storage data
		private Node<T> previous=null;//a reference which means the previous object of current node
		private Node<T> next=null;//a reference which means the next object of current node
		/**
		 * the constructor of Node
		 * @param value
		 * @param previous
		 * @param next
		 */
		public Node(T value, Node<T> previous, Node<T> next) {
			this.value = value;
			this.previous = previous;
			this.next = next;
		}

而循环双链表的所有操作，几乎都是围绕头结点操作的。下面是add方法：

        private void addBefore(Node<T> currentNode,T value){
		/*
		 * constructor a object of Node<T>,the value of this object is the param of object
		 * the previous of this value is headNode.previous(value=[null],previous=headNode,next=headNode)
		 * the next of this object is  headNode(value=[null],previous=headNode,next=headNode)
		 */
		Node<T> newNode=new Node<T>(value, currentNode.previous, currentNode);
		newNode.previous.next=newNode;
		newNode.next.previous=newNode;
		size++;
	}

remove方法如下：

public T remove(int index){
		rangeCheck(index);
		Node<T> node=getNode(index);
		T result = node.value;
		node.previous.next = node.next;
		node.next.previous = node.previous;
		size--;
		return result;

	}

完整的示例如下：

package com.lemon.linkedlist;

/**
 * This class realize the linkedlist of data structures
 * The object of MyLinkedList is good at the operation such as add or remove,
 * and the disadvantage is random access.
 * @author yanan
 * @param <T>
 */
public class MyLinkedList<T> {
	/**
	 * the number of this list
	 */
	private int size;
	
	/**
	 * construction method
	 */
	public MyLinkedList (){
		headNode.next = headNode.previous = headNode;
	}
	/**
	 * the header of this list
	 */
	private Node<T> headNode=new Node<T>(null, null, null);

	/**
	 * return a number of objects in this list
	 * @return
	 */
	public int size(){
		return size;
	}
	/**
	 * test this list whether is null or not
	 * @return
	 */
	public boolean isEmpty(){
		return size==0;
	}
	
	/**
	 * add an object to list 
	 * @param object
	 * @return
	 */
	public boolean add(T object){
		addBefore(headNode,object);
		return true;
	}
	/**
	 * get an object at specified position in this list
	 * @param index
	 * @return
	 */
	public T get(int index){
		rangeCheck(index);
		return this.getNode(index).value;
	}
	
	private void rangeCheck(int index){
		if (index < 0 || index >= size)
			throw new IndexOutOfBoundsException("Index: "+index+
					", Size: "+size);
	}
	
	/**
	 * return an array which contains all object,which belong to the list,from head to the last.
	 * @return
	 */
	public Object[] toArray(){
		Object[] result=new Object[size()];
		for(int i=0;i<result.length;i++){
			result[i]=headNode.next.value;
			headNode=headNode.next;
		}
		return result;
		
	}
	
	private Node<T> getNode(int index){
		
		Node<T> e = headNode;
		for(int i=0;i<size();i++){
			if(i==index){
				return e.next;
			}else{				
				e=e.next;
			}
		}
		return e;
	}
	/**
	 * remove an object at specified position which on behalf of index in this list
	 * return an object that has been removed from this list.
	 * @param index
	 * @return
	 */
	public T remove(int index){
		rangeCheck(index);
		Node<T> node=getNode(index);
		T result = node.value;
		node.previous.next = node.next;
		node.next.previous = node.previous;
		size--;
		return result;

	}

	private void addBefore(Node<T> currentNode,T value){
		/*
		 * constructor a object of Node<T>,the value of this object is the param of object
		 * the previous of this value is headNode.previous(value=[null],previous=headNode,next=headNode)
		 * the next of this object is  headNode(value=[null],previous=headNode,next=headNode)
		 */
		Node<T> newNode=new Node<T>(value, currentNode.previous, currentNode);
		newNode.previous.next=newNode;
		newNode.next.previous=newNode;
		size++;
	}

	/**
	 * a static class，which object that on behalf of an object of the MyLinkedList class
	 * @author yanan
	 * @param <T>
	 */
	private static class Node<T> {
		private T value=null;//use storage data
		private Node<T> previous=null;//a reference which means the previous object of current node
		private Node<T> next=null;//a reference which means the next object of current node
		/**
		 * the constructor of Node
		 * @param value
		 * @param previous
		 * @param next
		 */
		public Node(T value, Node<T> previous, Node<T> next) {
			this.value = value;
			this.previous = previous;
			this.next = next;
		}
	}
}

测试如下：

package com.lemon.linkedlist;



public class TestMyLinkedList {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		MyLinkedList<String> list=new MyLinkedList<String>();
		/**
		 * test add and get
		 */
		list.add("ChangNinNa");
		list.add("ChangNinMeng");
		list.add("ChangNinFang");
		System.out.println("after add....");
		for(int i=0;i<list.size();i++){
			System.out.println(list.get(i));
		}
		
		/**
		 * test remove
		 */
		list.remove(0);
		System.out.println("after remove....");
		for(int i=0;i<list.size();i++){
			System.out.println(list.get(i));
		}
		
		/**
		 * test toArray
		 */
		Object[] objs=list.toArray();
		for(int i=0;i<objs.length;i++){
			System.out.println(objs[i]);
		}
	}

}

当明白了双向链表的原理后，可以很容易理解：为什么Java中LinkedList长于删除、添加；而短于遍历。