常见面试题手写双向循环链表

public class DoubleLink<E> {

	private class Node<E> {
		public E value; // 节点值
		public Node<E> prev; // 前一个节点
		public Node<E> next; // 后一个节点

		public Node(E value, Node<E> prev, Node<E> next) {
			this.value = value;
			this.prev = prev;
			this.next = next;
		}
	}

	private int size;// 链表长度
	public Node<E> head;// 头节点

	/**
	 * constructor
	 */
	public DoubleLink() {
		// 头节点不存储值
		head = new Node<E>(null, null, null);
		head.prev = head.next = head;
		size = 0;
	}

	/**
	 * 获取链表的长度
	 * 
	 * @return
	 */
	public int size() {
		return size;
	}

	/**
	 * 判断链表是否为空
	 * 
	 * @return
	 */
	public boolean isEmpty() {
		return size == 0;
	}

	/**
	 * 验证索引的合法性
	 * 
	 * @param index
	 */
	public void rangeCheck(int index) {
		if (index < 0 || index >= size) {
			throw new IndexOutOfBoundsException();
		}
	}

	/**
	 * 获取位置为index的节点
	 * 
	 * @param index
	 * @return
	 */
	private Node<E> getNode(int index) {
		rangeCheck(index);
		if (index <= size / 2) {
			Node<E> cur = head.next;
			for (int i = 0; i < index; i++) {
				cur = cur.next;
			}
			return cur;
		}
		Node<E> cur = head.prev;
		int newIndex = size - index - 1;
		for (int i = 0; i < newIndex; i++) {
			cur = cur.prev;
		}
		return cur;
	}

	/**
	 * 获取位置为index的节点值
	 * 
	 * @return
	 */
	public E get(int index) {
		return getNode(index).value;
	}

	/**
	 * 获取第一个节点的值
	 * 
	 * @return
	 */
	public E getFirst() {
		return getNode(0).value;
	}

	/**
	 * 获取最后一个节点的值
	 * 
	 * @return
	 */
	public E getLast() {
		return getNode(size - 1).value;
	}

	/**
	 * 插入节点
	 * 
	 * @param index
	 * @param value
	 */
	public void insert(int index, E value) {
		if (index == 0) {
			Node<E> cur = new Node<E>(value, head, head.next);
			head.next.prev = cur;
			head.next = cur;
			size++;
			return;
		}

		Node<E> node = getNode(index - 1);
		Node<E> cur = new Node<E>(value, node, head);
		node.next = cur;
		head.prev = cur;
		size++;
	}

	/**
	 * 添加到链表的头部
	 * 
	 * @param value
	 */
	public void addFirst(E value) {
		insert(0, value);
	}

	/**
	 * 添加节点到链表的尾部
	 * 
	 * @param value
	 */
	public void addLast(E value) {
		Node<E> cur = new Node<E>(value, head.prev, head);
		head.prev.next = cur;
		head.prev = cur;
		size++;
	}

	/**
	 * 删除位置为index的节点
	 * 
	 * @param index
	 */
	public void delete(int index) {
		rangeCheck(index);
		Node<E> cur = getNode(index);
		cur.prev.next = cur.next;
		cur.next.prev = cur.prev;
		size--;
		cur = null;
	}

	/**
	 * 删除第一个节点
	 */
	public void deleteFirst() {
		delete(0);
	}

	/**
	 * 删除最后一个节点
	 */
	public void deleteLast() {
		delete(size - 1);
	}

	public static void main(String[] args) {
		DoubleLink<Integer> dl = new DoubleLink<Integer>();
		// Node<Integer> n1 = new Node<Integer>(1, dl.head, dl.head);
		dl.insert(0, 1);
		dl.insert(1, 2);
		dl.insert(2, 3);
		dl.insert(3, 4);
		// dl.addFirst(5);
		// dl.addLast(6);
		dl.deleteLast();
		// System.out.println(dl.getLast());
		// dl.removeFirst();
		// System.out.println(dl.get(1));
		for (int i = 0; i < dl.size; i++) {
			System.out.print(dl.get(i) + " ");
		}
	}

}