数据结构：线性表的链式存储(双向链表)--Java实现

public class DoubleLinkList<T> {
	// 定义内部类，节点类
	private class Node {
		private T data;
		// 上一节点
		private Node prev;
		// 下一节点
		private Node next;

		// 指定数据初始化
		public Node(T data, Node prev, Node next) {
			super();
			this.data = data;
			this.prev = prev;
			this.next = next;
		}
	}

	// 头结点
	private Node header;
	// 尾节点
	private Node tail;
	// 节点数
	private int size;

	// 空参初始化
	public DoubleLinkList() {
		header = tail = null;
	}

	// 有参初始化
	public DoubleLinkList(T element) {
		tail = header = new Node(element, null, null);
		size++;
	}

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

	// 判定链表是否为空
	public boolean empty() {
		return size == 0;
	}

	// 获取链表中指定节点
	private Node getNode(int index) {
		if (index < 0 || index > size) {
			throw new IndexOutOfBoundsException("双向链表越界");
		}
		if (index > size / 2) {
			Node key = tail;
			for (int i = size; i > size / 2 && key.prev != null; i--, key = key.prev) {
				if (i == index) {
					return key;
				}
			}
		} else {
			Node key = header;
			for (int i = 0; i < size / 2 && key.next != null; i++, key = key.next) {
				if (i == index) {
					return key;
				}
			}
		}

		return null;
	}

	// 获取指定节点存储的值
	public T get(int index) {
		return getNode(index).data;
	}

	// 查找双向链表中指定元素的索引值
	public int contain(T element) {
		Node key = header;
		for (int i = 0; i < size && key.next != null; i++, key = key.next) {
			if (key.data.equals(element)) {
				return i;
			}
		}
		return -1;
	}

	// 向双向链表中的指定位置插入元素
	public void insert(T element, int index) {
		if (index < 0 || index > size) {
			throw new IndexOutOfBoundsException("双向链表越界");
		}
		if (header == null) {
			add(element);
		} else {
			if (index == 0) {
				header = new Node(element, null, header);
				if (tail == null) {
					tail = header;
				}
			} else {
				Node prev = getNode(index - 1);
				Node next = prev.next;
				Node key = new Node(element, prev, next);
				prev.next = key;
				next.prev = key;
			}
			size++;
		}
	}

	// 向链表中添加元素----尾巴上添加元素
	public void add(T element) {
		if (header == null) {
			tail = header = new Node(element, null, null);
		} else {
			Node key = new Node(element, tail, null);
			tail.next = key;
		}
		size++;
	}

	// 删除链表中指定位置元素
	public T delete(int index) {
		if (index < 0 || index > size) {
			throw new IndexOutOfBoundsException("双向链表越界");
		}
		Node delNode = null;
		if (index == 0) {
			delNode = header;
			header = header.next;
			header.prev = null;
		} else if (index == size) {
			delNode = tail;
			tail = tail.prev;
			tail.next = null;
		} else {
			Node pre = getNode(index - 1);
			delNode = pre.next;
			pre.next = pre.next.next;
			pre.next.next.prev = pre;

		}
		size--;
		return delNode.data;
	}

	// 清空双向链表
	public void clear() {
		tail = header = null;
		size = 0;
	}

	// 取出双向链表最后一个元素
	public T remove() {
		return delete(size);
	}

	// 双向链表打印
	public String toString() {
		StringBuilder sb = new StringBuilder();
		if (empty()) {
			return "[]";
		} else {
			Node key = header;
			sb.append("[");
			for (int i = 0; i < size && key.next != null; i++, key = key.next) {
				sb.append(key.data + ",");
			}
			sb.append("]");
		}
		return sb.toString();
	}

}