简单数据结构实现——双链表

链表 (Linked List)，基本数据结构之一，是一种逻辑上的线性表，但是物理存储上是非线性的。在存储空间上分散排布，通过构造节点，以及节点中的前驱后驱指针来串联起所有的节点，顾名曰链表。这是一种随用随建的结构，删除起来也非常方便。链表的强项在于插入删除操作，但是链表的遍历是弱项，不能做到随机遍历，只能从头到尾顺序遍历。链表的还有一个好处是大小没有任何限制，java中自带的集合 ArrayList 就是一种链表结构（应该是单链表结构）。

在后面即将给出的实现，是双链表。即每个节点中即有一个前驱，也有一个后继，可以向后找到后继节点，也可以向前找到前驱节点。

单链表比双链表更简单，实现情形相差不大。

循环链表是头尾相接的链表，实现难度不会很大，有一些边界情况需要考虑，留待以后有兴趣的时候来实现。

如C语言等支持指针的语言中，链表一般使用指针来实现的，但是在java中的情况更简单，直接构造一个Node类（等于C中的结构体）来模拟节点，Node类中有两个Node型的变量：head和tail分别标明头尾节点。引入这两个虚拟节点可以消除很多特殊情况的处理，大大简化编程。还有一个属性data，即这个节点中真正有用的数据内容。

Node类可以考虑作为Linked List类的一个静态内部类。作为内部类，是因为这个Node类是强烈附属于链表类的，而且一般外部用户也理应对节点类没有兴趣。用static静态修饰是因为创建一个节点的时候可以不需要一个链表类的实例。

加入节点的方法add(AnyType x), add(int idx, AnyType x) 都将最终调用 addBefore(Node<AnyType> node, AnyType x)来解决。

剩下的一些细节看具体代码。

public class MyLinkedList<AnyType> implements Iterable<AnyType>{
	private Node<AnyType> head=new Node<AnyType>(null, null, null);
	private Node<AnyType> tail=new Node<AnyType>(null, null, null);
	private int size=0;
	
	private static class Node<AnyType>{
		AnyType data;
		Node<AnyType> prev;
		Node<AnyType> next;
		
		public Node(AnyType d, Node<AnyType> p, Node<AnyType> n){
			data=d;
			prev=p;
			next=n;
		}
	}
	
	public MyLinkedList(){
		head.next=tail;
		tail.prev=head;
	}
	
	public boolean isEmpty(){
		return size==0;
	}
	
	public int size(){
		return size;
	}
	
	public void clear(){
		head.next=tail;
		tail.prev=head;
		size=0;
	}
	
	public boolean add(AnyType x){
		add(size(),x);
		return true;
	}
	
	public void add(int idx, AnyType x){
		addBefore(getNode(idx),x);
	}
	
	public void addBefore(Node<AnyType> node, AnyType x){
		Node<AnyType> newNode=new Node<AnyType>(x,node.prev,node);
		newNode.prev.next=newNode;
		node.prev=newNode;
		size++;
	}
	
	//This will return the data of the node at position index.
	public AnyType get(int index){
		return getNode(index).data;
	}
	
	//Change the data of node at index, the old data will be returned.
	public AnyType set(int index, AnyType newVal){
		Node<AnyType> node=getNode(index);
		AnyType old=node.data;
		node.data=newVal;
		return old;
	}
	
	//Old data will be returned.
	public AnyType remove(int index){
		return remove(getNode(index));
	}
	
	public AnyType remove(Node<AnyType> node){
		AnyType old=node.data;
		node.prev.next=node.next;
		node.next.prev=node.prev;
		size--;
		return old;
	}

	public boolean isContained(AnyType x){
		boolean found=false;
		for(int i=0;i<size();i++){
			if(x==getNode(i).data){
				found=true;
				break;
			}
		}		
		return found;
	}
	
	public int getIndex(AnyType value){
		if(isContained(value)){
			for(int i=0;i<size();i++){
				 if(value==getNode(i).data){
					return i;
				}
			}
			
			return Integer.MIN_VALUE;
		}
		else return Integer.MIN_VALUE;
	}
	
	//This is a private method because external users shouldn't be interested in the concept of nodes.
	//This will return the node at position index, not the data.
	private Node<AnyType> getNode(int index){
	/*/	This is my solution, but it's not good enough.
		Used below if the solution from a book.
		It's better because it throws exception,
		It can also search from the tail to he half center to accelerate the preocess.
	*/	
		if(index<0||index>size()) throw new IndexOutOfBoundsException();
		else{
			Node node=head.next;
			for(int i=0;i<index;i++){
				node=node.next;
			}
			return node;
		}
	
	/*
		Node<AnyType> p;
		if(index<0||index>size()) throw new IndexOutOfBoundsException();
		
		if(index<size()/2){
			p=head;
			for(int i=0;i<index;i++)
				p=p.next;
		}
		else{
			p=tail;
			for(int i=size();i>index;i--)
				p=p.prev;
		}
		return p;
	*/
	}
	
	public java.util.Iterator<AnyType> iterator(){
		return null;
	}
	
	public String toString(){
		String str="";
		str+="[";
		for(int i=0;i<size();i++){
			str+=" "+getNode(i).data.toString();
		}
		str+=" ]";
		return str;
	}
	
	public static void main(String[] args){
		MyLinkedList<Integer> ll=new MyLinkedList<Integer>();
		
		ll.add(3);
		ll.add(4);
		ll.add(3);
		ll.add(100);
		ll.remove(9);
		System.out.println(ll);
	}
}