雙向鏈表

<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
清空後的鏈表爲：是空鏈表