链表 part02：24. 两两交换链表中的节点，19.删除链表的倒数第N个节点，面试题 02.07. 链表相交，142.环形链表II*

24. 两两交换链表中的节点

题目

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

思考历程

解题方法

1、cur要在待操作的两个节点前面
2、保存2号节点的左、右节点，防止失联
3、四个步骤，分别为：
cur指向2，2指向1的临时值，1指向3的临时值，cur向前移动2格

难点

1、循环终止条件：奇数、偶数
2、犯错：虚拟头节点写成 dummyhead = head
3、犯错：循环条件写成 cur->next!=0

代码

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyhead = new ListNode(0);
        dummyhead->next = head;//犯错了：忘写next
        ListNode* cur = dummyhead;
        while(cur->next!=nullptr&&cur->next->next!=nullptr) {
            ListNode* temp1 = cur->next;//要操作节点的左 存1
            ListNode* temp2 = cur->next->next->next;//要操作节点的右 存3

            cur->next = cur->next->next;//步骤一
            cur->next->next =  temp1;//步骤二
            cur->next->next->next = temp2;//步骤三

            cur = cur->next->next;//cur移动两格
        }        
        return dummyhead->next;
    }
};

19.删除链表的倒数第N个节点

题目

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。（进阶：你能尝试使用一趟扫描实现吗？）

示例 1：

输入：head = [1,2,3,4,5], n = 2，输出：[1,2,3,5] 示例 2：
输入：head = [1], n = 1，输出：[] 示例 3：
输入：head = [1,2], n = 1，输出：[1]

思考历程

• 初次想法：暴力解法：第一遍扫描找到n的位置，第二遍扫描删除指定元素

解题方法（快指针始终领先慢指针n+1）

• 双指针：让fast移动n+1步，然后让fast和slow同时移动，直到fast指向NULL，此时slow指向要删除的节点。

• 快指针先行：fast首先走n + 1步 ，原因：同时移动的时候slow才能指向删除节点的上一个节点（方便删除操作）。
• 快慢同时移动，直到fast指向末尾，此时slow指向待删除节点。
• 删除。

难点

• 精髓：fast首先走n + 1步

原因：删除第N个节点，那么我们当前遍历的指针一定要指向第N个节点的前一个节点

• 犯错：return head;

例如：当要删除的元素是原来的head时，只是链接断掉了，head位置保存的数值还在，所以仍然会返回原head值。因此正确写法为 return dummyhead->next;

• 犯错：while((n+1)- -&&fast!=nullptr)

应该是语法问题

代码

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyhead = new ListNode(0);
        dummyhead->next = head;
        ListNode* fast = dummyhead;
        ListNode* slow = dummyhead;
        int step = n + 1;
        while(step--&&fast!=nullptr){
            fast = fast->next;
        }
        while(fast!=nullptr){
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next;
        return dummyhead->next;//犯错：return head（当要删除的元素是原来的head时，只是链接断掉了，head位置保存的数值还在，所以要返回dummyhead->next）
    }
};

面试题 02.07. 链表相交

题目

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

思考历程

乍一看，看不懂题目的输入输出。“intersectVal”、“listA”、“listB”应该是描述如图所示的两个单链表结构。

解题方法（让两链表尾巴对齐）

1、求A、B的长度
2、长度差 gap
3、让更长的链表头为 curA
4、curA通过右移 gap，移到 curB 同起点
5、一起往后比较

难点（curA与curB的代表意义）

1、在计算完A、B的长度后，curA与curB要回到原位。
2、在“让更长的链表头为 curA”中，交换的是curA与curB，而不是headA，headB。因为后面的操作，都是直接移动curA（相对较长）、curB（相对较短），不关心实际的链表A、B。
3、这道题为什么不用虚拟头节点：不用对实际头节点做删除、修改等操作，只是单纯的比较

代码

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        //求长度、长度差、让更长的为curA、curA移到curB同起点、一起往后比较
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0;
        int lenB = 0;
        int gap = 0;
        while(curA!=NULL){
            lenA++;
            curA = curA->next;
        }
        while(curB!=NULL){
            lenB++;
            curB = curB->next;
        }
        // 让curA为最长链表的头，lenA为其长度
        curA = headA;
        curB = headB;
        if(lenA<lenB){
            swap(curA,curB);
            swap(lenA,lenB);
        }

        // 求长度差
        gap = lenA - lenB;
        while(gap--){
            curA = curA->next;
        }

        // 遍历curA 和 curB，遇到相同则直接返回
        while(curA != NULL){
            if(curA == curB){
                return curA;
            }            
            curA = curA->next;
            curB = curB->next; 
        }
        return NULL;
    }
};

142.环形链表II

题目

题意： 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
说明：不允许修改给定的链表。

解题方法（差速出发找相遇点、同速找入环口）

• 快慢指针：快指针以2v出发，慢指针以v出发
• 判断是否环：如果快指针遇到NULL，就不是环

while(fast != NULL && fast->next != NULL)

• 相遇：会在慢指针进环的第一圈内相遇
• 重新出发：一个指针从相遇点出发，另一个从起点出发，以同样速度前进，会在入环口相遇

起点->入环口 = 相遇点->入环口，由数学推导得来
或者看文章 环形链表的快慢指针相遇问题以及相遇位置的证明

难点（相遇点的特殊含义）

1、为什么会相遇：相对速度为v，总会追到
2、为什么是在慢指针的第一圈相遇：慢指针走一圈的时间，快指针已经走了两圈

3、判断是否为环的条件有两个：因为快指针是两格地跳

while(fast != NULL && fast->next != NULL)

4、犯错：两者重新出发，应该是在相遇的前提下，应该在 if(fast == slow) 内

错误代码：
            if(fast == slow){//相遇之后，才有下面操作
                ListNode* index1 = fast;//一个从相遇点出发
                ListNode* index2 = head;//一个从起点出发
            }    
            while(index1 != index2){
                index1 = index1->next;
                index2 = index2->next;
            }

代码

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fast->next != NULL){//因为fast是跳两格
            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;
    }
};