双向链表

<pre name="code" class="java">public class DoubleList<T> {
	private Node<T> head = null;
	private Node<T> tail = null;
	private int length = 0;
		
	public static void main(String[] args) {
		DoubleList<Integer> dl = new DoubleList<Integer>();
		System.out.println("是否为空："+dl.isEmpty());
		dl.addToHead(2);
		dl.addToHead(5);
		dl.addToHead(9);
		dl.addToTail(10);
		System.out.print("链表为：");
		dl.printList();
		dl.insertIndexAfter(2, 7);
		System.out.print("在第2个数后插入7后链表为为：");
		dl.printList();
		dl.insertIndexBefore(3, 13);
		System.out.print("在第3个数前插入13后链表为为：");
		dl.printList();
		dl.removeByKey(7);
		System.out.print("移除键值7后的链表为：");
		dl.printList();
		dl.removeByIndex(3);
		System.out.print("移除第3个数后的链表为：");
		dl.printList();
		dl.deleteFromHead();
		System.out.print("删除头部节点后的链表为：");
		dl.printList();
		dl.deleteFromTail();
		System.out.print("删除尾部节点后的链表为：");
		dl.printList();
		dl.updateKeyByIndex(1, 3);
		System.out.print("将第1个数更新为3后的链表为：");
		dl.printList();
		System.out.println("第2个节点为："+dl.getKeyByIndex(2));
		System.out.println("是否为空："+dl.isEmpty());
		System.out.println("是否包含5："+dl.isContains(5));
		System.out.println("链表长度为："+dl.getSize());
		System.out.println("头结点为："+dl.getHeadKey());
		System.out.println("尾结点为："+dl.getTailKey());
		dl.clearList();
		System.out.print("清空后的链表为：");
		dl.printList();
	}
	
	//构建一个空链表
	public DoubleList() {
		head = null;
		tail = null;
		length = 0;
	}
	
	//构建一个节点的链表
	public DoubleList(T data) {
		head  = new Node<T>(data);
		tail = head;
		length = 1;
	}
	
	//把一个节点插入到链表前面
	private void addToHead(T key) {
		if(head != null) {
			Node<T> nd = new Node<T>(key);
			nd.next = head;
			head.prev = nd;
			head = nd;
		} else {
			head = new Node<T>(key);
			tail = head;
		}
		length++;
	}
	
	//把一个节点插入到链表后面
	private void addToTail(T key) {
		if(tail != null) {
			Node<T> nd = new Node<T>(key);
			tail.next = nd;
			nd.prev = tail;
			tail = nd;
		} else {
			tail = new Node<T>(key);
			head = tail;
		}
		length++;
	}
	
	//在索引index前插入值
	private boolean insertIndexBefore(int index,T insertvalue) {
		if(index<1 || index>length) {
			System.err.println("索引越界");
			return false;
		}
		Node<T> insertNode = new Node<T>(insertvalue);
		Node<T> nd = head;
		int j=0;
		while(nd != null) {
			j++;
			if(j == index) {
				if(nd.prev == null) {
					addToHead(insertvalue);		
				} else {
					nd.prev.next = insertNode;
					insertNode.prev = nd.prev;
					insertNode.next = nd;
					nd.prev = insertNode;
					length++;
				}
				return true;
			}
			nd=nd.next;		
		}
		return false;
	}
	
	//在索引index后插入值
	private boolean insertIndexAfter(int index,T insertvalue) {
		if(index<1 || index>length) {
			System.err.println("索引越界");
			return false;
		}
		Node<T> insertNode = new Node<T>(insertvalue);
		Node<T> nd = head;
		int j=0;
		while(nd != null) {
			j++;
			if(j == index) {
				if(nd.next == null) {
					addToTail(insertvalue);
				} else {
					nd.next.prev = insertNode;
					insertNode.next = nd.next;
					nd.next = insertNode;
					insertNode.prev = nd;	
					length++;
				}
				return true;
			}
			nd=nd.next;
		}
		return false;
	}

	//移除第一个键值为key的节点
	private boolean removeByKey(T key) {
		Node<T> nd = head;
		while(nd != null) {
			if(key == nd.key) {
				if(nd.prev == null){
					return deleteFromHead();
				}else if(nd.next == null) {
					return deleteFromTail();
				}else {
					nd.prev.next = nd.next;
					nd.next.prev = nd.prev;
					length--;
				}
				return true;
			}
			nd = nd.next;
		}
		return false;
	}
	
	//移除索引为i的值
	private boolean removeByIndex(int index) {
		if(index<1 || index>length) {
			System.err.println("索引越界");
			return false;
		}
		Node<T> nd = head;
		int j=0;
		while(nd != null) {
			j++;
			if(j == index) {
				if(nd.prev == null){
					return deleteFromHead();
				}else if(nd.next == null) {
					return deleteFromTail();
				}else {
					nd.prev.next = nd.next;
					nd.next.prev = nd.prev;
					length--;
				}
				return true;
			}
			nd=nd.next;
		}	
		return false;
	}
	
	
	//删除尾部节点
	private boolean deleteFromTail() {
		if(tail == null) {
			return false;
		}else {
			tail.prev.next = null;
			tail = tail.prev;
			length--;
			return true;
		}
	}

	//删除头部节点
	private boolean deleteFromHead() {
		if(head == null) {
			return false;
		}else {
			head.next.prev = null;
			head = head.next;
			length--;
			return true;
		}
	}

	private boolean updateKeyByIndex(int i,T key) {
		if(i<1 || i>length) {
			System.err.println("索引越界");
			return false;
		}
		Node<T> nd = head;
		for(int j=i-1;j>0;j--) {
			nd = nd.next;
		}
		nd.key = key;
		return true;
	}
	
	//获得第i个键值
	private T getKeyByIndex(int i) {
		if(i<1 || i>length) {
			System.err.println("索引越界");
			return null;
		}
		Node<T> nd = head;
		for(int j=i-1;j>0;j--) {
			nd = nd.next;
		}
		return nd.key;
	}
	
	private boolean isEmpty() {
		return length == 0;
	}
	
	private boolean isContains(T key) {
		Node<T> nd = head;
		while(nd != null) {
			if(nd.key == key) {
				return true;
			}
			nd = nd.next;
		}
		return false;
	}
	
	private int getSize() {
		return length;
	}
	
	private T getHeadKey() {
		return head.key;
	}
	
	private T getTailKey() {
		return tail.key;
	}
		
	private void printList() {
		if(isEmpty()) {
			System.out.println("是空链表");
		} else {
			Node<T> temp = head;
			while(temp != null) {
				System.out.print(temp.key+" ");
				temp = temp.next;
			}
		}

		System.out.println();
	}
	
	private void clearList() {
		head = null;
		tail = null;
		length = 0;
	}

	private static class Node<T> {

		Node<T> prev = null;
		Node<T> next = null;
		T key = null;
		
		public Node(T key) {
			this.key = key;
		}
	}
}

运行结果为：

是否为空：true
链表为：9 5 2 10 
在第2个数后插入7后链表为为：9 5 7 2 10 
在第3个数前插入13后链表为为：9 5 13 7 2 10 
移除键值7后的链表为：9 5 13 2 10 
移除第3个数后的链表为：9 5 2 10 
删除头部节点后的链表为：5 2 10 
删除尾部节点后的链表为：5 2 
将第1个数更新为3后的链表为：3 2 
第2个节点为：2
是否为空：false
是否包含5：false
链表长度为：2
头结点为：3
尾结点为：2
清空后的链表为：是空链表