【定义】链表是一种递归的数据结构，它或者为空（null），或者指向一个节点（node）的引用，这个节点含有泛型的元素和一个指向另一条链表的引用。
public class Node { Item item; Node next; }
【基本操作】为了维护一个链表，我们需要对链表：创建、插入、删除、遍历等四种操作。
1. 创建（构造）链表：根据链表定义，我们只需要一个Node类型的变量就能表示一条链表，只要保证它的值是null或者指向另一个Node对象且该对象的next域指向了另一条链表即可。比如按一下代码创建链表：
Node first = new Node(); Node second = new Node(); Node third = new Node(); first.item = "to"; second.item = "be"; third.item = "or"; first.next = second; second.next = third;
这时third是一个含单元素的链表，second是一个含双元素（second、third）的链表，first是一个含三个元素（first、second、third）的链表。
2. 在链表中插入元素最容易做到的地方是表头，他所需的时间与表的长度无关。简易代码：
public Node insertFirst() { Node oldfirst = first; first = new Node(); first.item = "not"; first.next = oldfirst; return first; }
3. 接下来你可能需要删除一条链表的首节点，这个操作更简单，只需返回表头节点的next节点即可。简易代码：
public Node deleteFirst() { if (isEmpty()) throw new NullPointerException(); return first.next; }
4. 如何在表尾插入节点，要完成这一任务，我们需要一个指向链表最后一个节点的链接，因为该节点的链接必须被修改并指向一个含有新元素的新节点。我们不能在链接代码中草率地决定维护一个额外的链接，因为每个修改链表的操作都需要添加检查是否要修改该变量（以及作出相应修改）的代码。比如链表只含有一个元素或者链表为空链表时。简易代码：
public Node getTail() { Node p = first; while(p.next != null) p = p.next; return p; }
5. 如何删除尾节点，last链接帮不上忙，只能遍历整个链表找到指向last链接的节点。简易代码：
public void deleteTail() { Node p = first, q; while(p.next != null) {q = p; p = p.next;}
q.next = p.next.next; }
6. 删除指定的节点。
public void Node deleteNode(Node p){ if(isEmpty()) throw new NoSuchElementException(); if(first.next == null) { if (first == p) first = null; else throw new NoSuchElementException(); } Node pPre, q = first; boolean find = false; while(q != null) { if (q == p) { find = true; break;} pPre = q; q = q.next; } if (!find) throw new NoSuchElementException(); pPre = q.next; }
7. 在指定节点前插入一个新节点。
public void Node insertNode(Node p, Node q){ if(isEmpty()) {first = last = p; } if (p == first) { q.next = first; first = q; } else { Node r = findPrior(p); if (r == null) throw new NoSuchElementException(); q.next = p; r.next = q; } }
【常见问题】
1. 反转链表：输入一个链表的头结点，反转该链表，并返回反转后链表的头结点。
首先要画清楚翻转的操作图（下图为一次翻转操作，遍历全链表即可完成整个链表的反转）：
然后依图即可写出代码：
public void reverse() { if (first == null || first.next == null) return; Node<Item> pPre = null, pNext, pCur = first; while(pCur != null) { pNext = pCur.next; pCur.next = pPre; pPre = pCur; pCur = pNext; } first = pPre; }
2. 判断链表是否有环。
这是一个经典的快慢指针问题。通过两个指针，分别从链表的头节点出发，一个每次向后移动一步，另一个移动两步，因为两个指针移动速度不一样，如果存在环，那么两个指针一定会在环里相遇。
一个有环链表如下图示：
相关代码：
public boolean hasCircle() { if (first == null || first.next == null) return false; Node fast, slow; fast = first; slow = first; while(fast != null && fast.next!= null) { if (fast.next.next == null) return false; fast = fast.next.next; slow = slow.next; if(fast == slow) return true; } return false; }
3. 判断有环链表的入口。
方法一： 暴力求解。先通过快慢指针，找到相遇的节点。遍历此节点得到整个环的元素。然后从链表头再次出发，每走一步与环的元素进行比较。
方法二：假定起点p到环入口点s的距离为a，fast和slow的相交点t与环入口点s的距离为b，环的周长为P，当fast和slow第一次相遇的时候，假定slow走了n 步。那么参考下图有：
slow走的长度：a+b = n；
fast走的长度：a + b + k*P = 2*n；
fast比slow多走了k圈环路，总路程是slow的2倍。
根据上述公式可以得到： n = k*P = a+b，
如果从相遇点t开始，再走 k*P-b (= a)步的话，亦即从s位置走了(k*P -b) + b步，t可以走到s的位置。
算法：设fast回到最初的位置p，每次行进一步，这样fast走了a步的时候，t也走到了s，两者相遇。
相关代码：
public Node findLoopNode() { if (first == null || first.next == null) return null; Node fast, slow; fast = first; slow = first; while(fast != null && fast.next!= null) { if (fast.next.next == null) return null; fast = fast.next.next; slow = slow.next; if(fast == slow) break; } if(fast != slow) return null; fast = first; while(fast != slow) { fast = fast.next; slow = slow.next; } return fast; }
4. 求链表相交。
方法一：可转化为环问题求解，将一个链表链接到另一个链表后，通过快慢指针是否相交求解。
方法二：链表相交则其尾部一定一致，因此可以通过判断尾节点是否一致判断。
相关代码略。
5. 两个有序链表合并为一个有序链表。
原理与归并排序merge操作一致，代码略。