public class LinkedList<E> {

	private class Node {
		public E e;
		public Node next;

		public Node(E e, Node next) {
			this.e = e;
			this.next = next;
		}

		public Node(E e) {
			this(e, null);
		}

		public Node() {
			this(null, null);
		}

		@Override
		public String toString() {
			return e.toString();
		}
	}

	private Node dummyHead;
	private int size;

	public LinkedList() {
		dummyHead = new Node();
		size = 0;
	}

	// 獲取連結串列中的元素個數
	public int getSize() {
		return size;
	}

	// 返回連結串列是否為空
	public boolean isEmpty() {
		return size == 0;
	}

	// 在連結串列的index(0-based)位置新增新的元素e
	// 在連結串列中不是一個常用的操作，練習用：）
	public void add(int index, E e) {

		if (index < 0 || index > size)
			throw new IllegalArgumentException("Add failed. Illegal index.");

		Node prev = dummyHead;
		for (int i = 0; i < index; i++)
			prev = prev.next;

		prev.next = new Node(e, prev.next);
		size++;
	}

	// 在連結串列頭新增新的元素e
	public void addFirst(E e) {
		add(0, e);
	}

	// 在連結串列末尾新增新的元素e
	public void addLast(E e) {
		add(size, e);
	}

	// 獲得連結串列的第index(0-based)個位置的元素
	// 在連結串列中不是一個常用的操作，練習用：）
	public E get(int index) {

		if (index < 0 || index >= size)
			throw new IllegalArgumentException("Get failed. Illegal index.");

		Node cur = dummyHead.next;
		for (int i = 0; i < index; i++)
			cur = cur.next;
		return cur.e;
	}

	// 獲得連結串列的第一個元素
	public E getFirst() {
		return get(0);
	}

	// 獲得連結串列的最後一個元素
	public E getLast() {
		return get(size - 1);
	}

	// 修改連結串列的第index(0-based)個位置的元素為e
	// 在連結串列中不是一個常用的操作，練習用：）
	public void set(int index, E e) {
		if (index < 0 || index >= size)
			throw new IllegalArgumentException("Set failed. Illegal index.");

		Node cur = dummyHead.next;
		for (int i = 0; i < index; i++)
			cur = cur.next;
		cur.e = e;
	}

	// 查詢連結串列中是否有元素e
	public boolean contains(E e) {
		Node cur = dummyHead.next;
		while (cur != null) {
			if (cur.e.equals(e))
				return true;
			cur = cur.next;
		}
		return false;
	}

	// 從連結串列中刪除index(0-based)位置的元素, 返回刪除的元素
	// 在連結串列中不是一個常用的操作，練習用：）
	public E remove(int index) {
		if (index < 0 || index >= size)
			throw new IllegalArgumentException("Remove failed. Index is illegal.");

		Node prev = dummyHead;
		for (int i = 0; i < index; i++)
			prev = prev.next;

		Node retNode = prev.next;
		prev.next = retNode.next;
		retNode.next = null;
		size--;

		return retNode.e;
	}

	// 從連結串列中刪除第一個元素, 返回刪除的元素
	public E removeFirst() {
		return remove(0);
	}

	// 從連結串列中刪除最後一個元素, 返回刪除的元素
	public E removeLast() {
		return remove(size - 1);
	}

	// 從連結串列中刪除元素e
	public void removeElement(E e) {

		Node prev = dummyHead;
		while (prev.next != null) {
			if (prev.next.e.equals(e))
				break;
			prev = prev.next;
		}

		if (prev.next != null) {
			Node delNode = prev.next;
			prev.next = delNode.next;
			delNode.next = null;
		}
	}

	@Override
	public String toString() {
		StringBuilder res = new StringBuilder();

		Node cur = dummyHead.next;
		while (cur != null) {
			res.append(cur + "->");
			cur = cur.next;
		}
		res.append("NULL");

		return res.toString();
	}
}
 

測試程式碼

public class Test {
	public static void main(String[] args) {

		LinkedList<Integer> linkedList = new LinkedList<>();
		for (int i = 0; i < 10; i++) {
			linkedList.addFirst(i);
			System.out.println(linkedList);
		}

		linkedList.add(2, 666);
		System.out.println(linkedList);

		linkedList.remove(2);
		System.out.println(linkedList);

		linkedList.removeFirst();
		System.out.println(linkedList);

		linkedList.removeLast();
		System.out.println(linkedList);
	}
}
 

執行結果