我的Java单链表练习

package LinkedList;

/**
 * <p><strong>我的Java单链表练习</strong></p>
 * <p>单链表提供了在列表头的高效插入和删除操作，不过在单链表的末尾的插入操作效率很低.</p>
 * <p>单链表指针域保存着下一节点的引用，尾结点的指针域等于null</p>
 * @author baby69yy2000
 */
public class SingleLinkedList<T> {

	/**
	 * 结点类
	 */
	private static class Node<T> {
		T nodeValue; // 数据域
		Node<T> next; // 指针域保存着下一节点的引用

		Node(T nodeValue, Node<T> next) {
			this.nodeValue = nodeValue;
			this.next = next;
		}

		Node(T nodeValue) {
			this(nodeValue, null);
		}
	}

	// 下面是SingleLinkedList类的数据成员和方法
	private Node<T> head, tail;

	public SingleLinkedList() {
		head = tail = null;
	}

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

	/**
	 * 创建头指针，该方法只用一次！
	 */
	public void addToHead(T item) {
		head = new Node<T>(item);
		if(tail == null) tail = head;
	}

	/**
	 * 添加尾指针，该方法使用多次
	 */
	public void addToTail(T item) {
		if (!isEmpty()) { // 若链表非空那么将尾指针的next初使化为一个新的元素
			tail.next = new Node<T>(item); // 然后将尾指针指向现在它自己的下一个元素
			tail = tail.next;
		} else { // 如果为空则创建一个新的！并将头尾同时指向它
			head = tail = new Node<T>(item);		
		}
	}

	/**
	 * 打印列表
	 */
	public void printList() {
		if (isEmpty()) {
			System.out.println("null");
		} else {
			for(Node<T> p = head; p != null; p = p.next)
				System.out.println(p.nodeValue);
		}
	}

	/**
	 * 在表头插入结点，效率非常高
	 */
	public void addFirst(T item) {
		Node<T> newNode = new Node<T>(item);
		newNode.next = head;
		head = newNode;
	}

	/**
	 * 在表尾插入结点，效率很低
	 */
	public void addLast(T item) {
		Node<T> newNode = new Node<T>(item);
		Node<T> p = head;
		while (p.next != null) p = p.next;
		p.next = newNode;
		newNode.next = null;
	}

	/**
	 * 在表头删除结点，效率非常高
	 */
	public void removeFirst() {
		if (!isEmpty()) head = head.next;
		else System.out.println("The list have been emptied!");
	}

	/**
	 * 在表尾删除结点，效率很低
	 */
	public void removeLast() {
		Node<T> prev = null, curr = head;
		while(curr.next != null) {
			prev = curr;
			curr = curr.next;
			if(curr.next == null) prev.next = null;
		}
	}

	/**
	 * <p>插入一个新结点</p>
	 * <ul>插入操作可能有四种情况:
	 * <li>①表为空, 返回false</li>
	 * <li>②表非空,指定的数据不存在</li>
	 * <li>③指定的数据是表的第一个元素</li>
	 * <li>④指定的数据在表的中间</li></ul>
	 * @param appointedItem 指定的nodeValue
	 * @param item 要插入的结点
	 * @return 成功插入返回true;
	 */
	public boolean insert(T appointedItem, T item) {
		Node<T>  prev = head, curr = head.next, newNode;
		newNode = new Node<T>(item);
		if(!isEmpty()) {
			while((curr != null) && (!appointedItem.equals(curr.nodeValue))) { //两个判断条件不能换
				prev = curr;
				curr = curr.next;
			}
			newNode.next = curr; //②③④
			prev.next = newNode;
			return true; 
		}
		return false; //①
	}

	/**
	 * <p>移除此列表中首次出现的指定元素</p>
	 * <ul>删除操作可能出现的情况:
	 * <li>①prev为空，这意味着curr为head. head = curr.next; --> removeFirst();</li>
	 * <li>②匹配出现在列表中的某个中间位置，此时执行的操作是 --> prev.next = curr.next;,</li></ul>
	 * <p>在列表中定位某个结点需要两个引用:一个对前一结点(prev左)的引用以及一个对当前结点(curr右)的引用.</p>
	 * prev = curr;
	 * curr = curr.next;
	 */
	public void remove(T item) {
		Node<T> curr = head, prev = null;
		boolean found = false;
		while (curr != null && !found) {
			if (item.equals(curr.nodeValue)) {
				if(prev == null) removeFirst();
				else prev.next = curr.next;
				found = true;
			} else {
				prev = curr;
				curr = curr.next;
			}
		}
	}

	/**
	 * 返回此列表中首次出现的指定元素的索引，如果列表中不包含此元素，则返回 -1.
	 */
	public int indexOf(T item) {
		int index = 0;
		Node<T> p;
		for(p = head; p != null; p = p.next) {
			if(item.equals(p.nodeValue))
				return index;
			index++;

		}
		return -1;
	}

	/**
	 * 如果此列表包含指定元素，则返回 true。
	 */
	 public boolean contains(T item) {
		 return indexOf(item) != -1;
	 }

	public static void main(String[] args) {
		SingleLinkedList<String> t = new SingleLinkedList<String>();
		t.addToHead("A");
		//t.addFirst("addFirst");
		t.addToTail("B");
		t.addToTail("C");
		System.out.println(t.indexOf("C")); // 2
		System.out.println(t.contains("A")); // true
		//t.addLast("addLast");
		//t.removeLast();
		//t.insert("B", "insert");
		//t.removeFirst();
		//t.remove("B"); // A C
		t.printList(); // A B C

	}

}