内容：
- 两两交换链表中的节点(24)
- 删除链表的倒数第N个节点(19)
- 链表相交(160)
- 环形链表II(142)
1.两两交换链表中的节点
1.1 思路分析
思路是比较简单，对于头结点的处理我们依旧定义虚拟头结点。
初始时，cur指向虚拟头结点，然后进行如下三步：
操作之后，链表如下：
看这个可能就更直观一些了：
1.2 代码实现
class Solution {
public ListNode swapPairs(ListNode head) {
//虚拟头结点
ListNode dummyHead = new ListNode(0);
//不要忘了将虚拟头结点与head建立连接
dummyHead.next = head;
ListNode cur = dummyHead;//定义指针cur 指向我们的虚拟头节点
//while循环遍历
while(cur.next != null && cur.next.next != null){
//用 temp1 保存我们的cur的下一个节点
ListNode temp1 = cur.next;
ListNode temp2 = cur.next.next.next;
cur.next = cur.next.next;
//这里不可以将cur.next 换成temp1,理解指针的指向
cur.next.next = temp1;
temp1.next = temp2;
//cur后移
cur = cur.next.next;
}
return dummyHead.next;
}
}
1.3 注意事项
- 对于这种题目要善用虚拟头结点，同时画图来理清内部的一些关系
2.删除链表的倒数第N个节点
2.1 思路分析
最直接的思路就是遍历整个链表得到其长度，然后for循环让指针指向要删除节点的前一个节点，执行普通的删除操作即可。
2.2 代码实现
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode cur = head;
int size = 0;//记录节点的个数
//获取链表的的节点个数
while(cur != null){
size++;
cur = cur.next;
}
ListNode dummyHead = new ListNode(0);//虚拟头结点
dummyHead.next = head;
ListNode pre = dummyHead;//pre指向要删除节点的前一位
for(int i = 0;i < size - n;i++){
pre = pre.next;
}
//这时pre指向了要删除节点的前一位
pre.next = pre.next.next;
return dummyHead.next;
}
}
2.3 注意事项
- for循环遍历时搞清楚循环条件，要让pre指向删除节点的前一位
3.相交链表
3.1 思路分析
定义两个指针curA,curB分别指向链表的头部，我们求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB末尾对齐的位置,如图:
此时我们就可以比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。
否则循环退出返回空指针。
3.2 代码实现
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
//交点不是数值相等，而是指针相等
ListNode curA = headA;
ListNode curB = headB;
int lengthA = 0;
int lengthB = 0;
while(curA != null){
lengthA++;
curA = curA.next;
}
while(curB != null){
lengthB++;
curB = curB.next;
}
curA = headA;
curB = headB;
if (lengthB > lengthA){
int temp = lengthB;
lengthB = lengthA;
lengthA = temp;
ListNode temp1= curB;
curB = curA;
curA = temp1;
}
int gap = lengthA - lengthB;
while(gap -- > 0){
curA = curA.next;
}
while(curA != null){
if (curA == curB){
return curA;
}
curA = curA.next;
curB = curB.next;
}
return null;
}
}
3.3 注意事项
- 理解题目相交的意思：交点不是数值相等，而是指针相等。
4.环形链表II
4.1 思路分析
这里的思路分析我就以问题的形式来写了，这个环形链表我们需要解决：
- 链表是否有环
- 有环的话，为什么一定会在环内相遇呢，而不是永远的错开呢
- 为什么第一次在环中相遇，slow的 步数 是 x+y 而不是 x + 若干环的长度 + y 呢？
- 为什么从头结点出发一个指针，从相遇节点出发一个指针，这两个指针每次只走一个节点，这两个指针相遇的时候就是环形入口的节点
4.2 代码实现
public class Solution {
public ListNode detectCycle(ListNode head) {
//定义两个指针fast , slow
ListNode fast = head;
ListNode slow = head;
while(fast != null && fast.next != null){
fast = fast.next.next;
slow = slow.next;
//如果两个指针相遇
if (fast == slow){
ListNode index1 = fast;
ListNode index2 = head;
//如果两个索引相等，则为环的入口
while(index1 != index2){
index1 = index1.next;
index2 = index2.next;
}
return index1;
}
}
return null;
}
}
4.3 问题解答
- 可以使用快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环
- fast指针一定先进入环内，slow后进，如果fast指针和slow指针相遇的话，一定是在环中相遇，而fast指针相对于slow指针是一步一步接近的，所以一定会在环内相遇
- 可以这么理解，当slow出现在环的入口时，fast一定在环内的某个位置，而slow要想走完一圈，必须将每个点都走一遍，而fast指针是一个节点一个节点靠近slow的，所以它走的节点一定是小于等于一圈的长度的，所以slow会在第一圈与fast相遇
-
- 假设从头结点到环形入口节点 的节点数为x。 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。 从相遇节点 再到环形入口节点节点数为 z
如图所示：
那么相遇时： slow指针走过的节点数为:
x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：
(x + y) * 2 = x + y + n (y + z)两边消掉一个（x+y）:
x + y = n (y + z)因为要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离。
所以要求x ，将x单独放在左面：
x = n (y + z) - y,再从n(y+z)中提出一个 （y+z）来，整理公式之后为如下公式：
x = (n - 1) (y + z) + z注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。这个公式说明什么呢？
先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。
当 n为1的时候，公式就化解为
x = z，这就意味着，从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。
那么 n如果大于1是什么情况呢，就是fast指针在环形转n圈之后才遇到 slow指针。
其实这种情况和n为1的时候 效果是一样的，一样可以通过这个方法找到 环形的入口节点，只不过,index1 指针在环里 多转了(n-1)圈，然后再遇到index2，相遇点依然是环形的入口节点。