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

public class LinkList<T> {
	// 链表结点Node，封装成内部类
	private class Node {
		// 保存节点数据
		private T data;
		// 指向下一个元素
		private Node next;

		// 指定元素与下一元素的构造方法
		public Node(T data, Node next) {
			this.data = data;
			this.next = next;
		}
	}

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

	// 创建空链表
	public LinkList() {
		header = null;
		tail = null;
	}

	// 指定参数初始化链表
	public LinkList(T element) {
		header = tail = new Node(element, null);
		size++;
	}

	// 返回链表长度
	public int length() {
		return size;
	}

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

	// 向链表尾添加元素
	public void add(T element) {
		Insert(element, size - 1);
	}

	// 向指定位置插入元素
	public void Insert(T element, int index) {
		if (index < 0 || index > size ) {
			throw new IndexOutOfBoundsException("线性表越界");
		}
		if (header == null) {
			tail = header = new Node(element, null);
		}
		if ( size == index ) {
			Node endNode = new Node(element, null);
			tail.next = endNode;
			tail = endNode;
			size++;                                                                                                                  } else {
			Node prev = getIndex(index - 1);
			prev.next = new Node(element, prev.next);
			size++;
		}

	}

	// 获取指定位置上的节点
	private Node getIndex(int index) {
		if (index < 0 || index > size - 1) {
			throw new IndexOutOfBoundsException("线性表越界");
		}
		Node search = header;
		for (int i = 0; i < size; i++, search = search.next) {
			if (i == index) {
				return search;
			}
		}
		return null;
	}

	// 获取指定位置上的元素
	public T getData(int index) {
		Node key = getIndex(index);
		return key.data;
	}

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

	// 删除末尾元素
	public T remove() {
		return delete(size - 1);
	}

	// 删除指定位置上元素
	public T delete(int index) {
		if (index < 0 || index > size) {
			throw new IndexOutOfBoundsException("线性表越界");
		}
		Node key = null;
		if (index == 0) {
			key = header;
			header = header.next;
			size--;
			return header.data;
		} else {
			Node prev = getIndex(index - 1);
			key = prev.next;
			prev.next = key.next;
			key.next = null;
			return key.data;
		}
	}

	// 清空线性表
	public void clear() {
		header = tail = null;
		size = 0;
	}

	// 输出
	public String toString() {
		StringBuilder sb = new StringBuilder();
		if (size == 0) {
			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();
	}

}