代码随想录算法训练营第四天 |24. 两两交换链表中的节点、19.删除链表的倒数第N个节点、面试题 02.07. 链表相交、142.环形链表II

题目链接：leetcode 24、两两交换链表中的节点

文章讲解：代码随想录 24、两两交换链表中的节点

视频讲解：帮你把链表细节学清楚！ | LeetCode：24. 两两交换链表中的节点

思路和解法

这个系列从这篇开始不区分自己第一思路和看完讲解后的思路了，后面题越来越难，我也都是第一次见，估计都会写出bug，提供错误答案意义不大。但是我会把第一想法，和看完讲解后的收获以及解答需要注意的细节都写出来，只是总结在一起了。

题目： 给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
想法： 和反转链表有相似之处，即把两个链表节点换位，回顾反转链表，交换两个节点一定要有一个临时变量存储被交换的第二个节点的下一个节点地址。对于交换的操作，就用双指针，一个前pre一个后curr。这种题思考的时候注意一下双指针给到哪里，curr是给到被交换的第一个还是第二个。这里统一一下就给到被交换的第一个节点，初始化的时候pre给虚拟头节点。因为一般还是有虚拟头节点好，这样规定，pre也有了好的默认值，就是虚拟头节点。
另外还要注意循环条件，这个会犯操作空指针的错误，首先看循环体里都要访问哪些节点，要保证循环条件判断到了最远节点的前一个节点地址不为空，这样访问最远的节点才不会报错，不然就是操作空指针，最远节点地址为nullptr无所谓，因为循环体里只是赋值，不会访问这个空指针。
上面着一段描述有点啰嗦，总结一下就是不要访问空指针，在循环条件里判断好，什么才算是访问，举个例子curr -> next = curr -> next -> next; 这句代码访问了curr，访问了curr -> next，但是没有访问curr -> next -> next。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* HEAD = new ListNode();
        HEAD -> next = head;
        ListNode* pre = HEAD;
        ListNode* curr =head;
        while (curr != nullptr && curr -> next != nullptr) {
            ListNode* nextcurr = curr -> next -> next;
            pre -> next = curr -> next;
            pre -> next -> next = curr;
            curr -> next = nextcurr;
            pre = curr;
            curr = nextcurr;
        }
        return HEAD -> next;
    }
};

注意创建指针时赋初值，nullptr也可以，防止操作野指针。

题目链接：leetcode 19、删除链表的倒数第N个节点

文章讲解：代码随想录 19、删除链表的倒数第N个节点

视频讲解：链表遍历学清楚！ | LeetCode：19.删除链表倒数第N个节点

思路和解法

题目： 给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
想法： 这个做过有点印象，知道用双指针找目标节点。

自己写的代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* HEAD = new ListNode();
        HEAD -> next = head;
        ListNode* indexNode = head;
        ListNode* curr = HEAD;
        while (n-- && indexNode!= nullptr) {
            indexNode = indexNode -> next;
        }
        while (indexNode != nullptr) {
            indexNode = indexNode -> next;
            curr = curr -> next;
        }
        //删除curr节点
        ListNode* deleteNode = curr -> next;
        curr -> next = curr -> next -> next;
        delete deleteNode;
        deleteNode = nullptr;
        return HEAD -> next;
    }
};

讲解给的代码：

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* slow = dummyHead;
        ListNode* fast = dummyHead;
        while(n-- && fast != NULL) {
            fast = fast->next;
        }
        fast = fast->next; // fast再提前走一步，因为需要让slow指向删除节点的上一个节点
        while (fast != NULL) {
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next; 
        
        // ListNode *tmp = slow->next;  C++释放内存的逻辑
        // slow->next = tmp->next;
        // delete nth;
        
        return dummyHead->next;
    }
};

还是喜欢自己思路写出来的代码，用了虚拟头节点，注意细节，循环条件的设置防止访问空指针；这道题目只是删除节点，所以一共三个指针，一个快指针用来找目标节点，一个用来删除的访问指针，最后删除的时候为了严谨，手动释放内存再用一个指针。

题目链接：leetcode 面试题 02.07. 链表相交

文章讲解：代码随想录 面试题 02.07. 链表相交讲解

视频讲解：无

思路和解法

题目： 给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
想法： 自己想没想出来。学习过后总结如下，关键思想是由于相交节点的存在，从链表后面开始数相交节点对于两个链表是相同位置。

那么怎么找相交节点，链表是只能从前向后访问的，所以不能从后面开始找，只能从前面开始找，利用上面提到的特点，我们设两个指针分别访问两个链表，长链表的指针先向后移动与短链表指针对齐，然后开始比较指针是否相同，==注意是比较指针，不是比较节点里的值，==如果相等说明两个指针走到了相交节点处，返回此时的指针即可。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int counta = 0;
        int countb = 0;
        ListNode* dummyheadA = new ListNode();
        dummyheadA -> next = headA;
        ListNode* dummyheadB = new ListNode();
        dummyheadB -> next = headB;
        //计算A链表长度
        ListNode* currA = headA;
        while (currA != nullptr) {
            currA = currA -> next;
            counta++;
        }
        //计算B链表长度
        ListNode* currB = headB;
        while (currB != nullptr) {
            currB = currB -> next;
            countb++;
        }
        int n = abs(counta - countb);
        currA = dummyheadA;
        currB = dummyheadB;
        //先动A链表指针
        if (counta >= countb) {
            while (n--) {
                currA = currA -> next;
            }
        } else {
            while (n--) {
                currB = currB -> next;
            }
        }
        //开始比较链表是否有交点
        while (currA -> next != nullptr && currB -> next != nullptr) {
            if (currA -> next == currB -> next) {
                return currA -> next;
            }
            currA = currA -> next;
            currB = currB -> next;
        }
        return nullptr;
    }
};

题目链接：leetcode 142.环形链表II

文章讲解：代码随想录 142.环形链表II

视频讲解：把环形链表讲清楚！| LeetCode:142.环形链表II

思路和解法

题目： 给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。
想法： 做过一次，这次完全想不到怎么解。快慢指针扣圈这个思路太巧妙了，总结如下：

这个题目要解决两个问题，是否有环，环的起点在哪里。
利用快慢指针确认是否有环，快指针每次移动两步，慢指针每次移动一步，防止刚好错过。找环的起点的思路推导过程有点巧妙，不太好想，所以当作经验记住好了。关键理解：第一次相遇的时候，快指针比慢指针多走了n圈，此时慢指针回到链表起点，两个指针开始同时每次移动一步，再次相遇时一定在环的起点。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while (fast != nullptr && fast -> next != nullptr) {
            fast = fast -> next -> next;
            slow = slow -> next;
            if (slow == fast) {
                ListNode* index1 = head;
                ListNode* index2 = fast;
                while (index1 != index2) {
                    index1 = index1 -> next;
                    index2 = index2 -> next;
                }
                return index1;
            }
        }
        return nullptr;
    }
};