今日任务：
24. 两两交换链表中的节点
19.删除链表的倒数第N个节点
面试题 02.07. 链表相交
142.环形链表II
状态：1刷

前言

链表多考虑用虚拟头结点，这样会方便很多，
双指针的操作注意，删除第N个节点，那么我们当前遍历的指针一定要指向 第N个节点的前一个节点

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

题目：给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换
思路：虚拟头节点+画图，要厘清指针顺序
代码：

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0);// 虚拟头节点
        dummyHead->next = head;
        ListNode* cur = dummyHead;
        while (cur->next != nullptr && cur->next->next != nullptr){// 同时满足
            ListNode* temp = cur->next;// 保存 节点1
            ListNode* temp1 = cur->next->next->next;// 保存 节点3
            cur->next = cur->next->next;// 第一步，断开0-1节点,0->2
            cur->next->next = temp;// 第二步 2->1
            temp->next = temp1;// 1->3
            cur = cur->next->next;
        }
        head = dummyHead->next;
        return head;
    }
};

时间复杂度：O(n)
空间复杂度：O(1)

二、19. 删除链表的倒数第 N 个结点

题目：给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
思路：双指针的经典应用，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。
代码如下（示例）：

 // 双指针的经典应用
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* fast = dummyHead;
        ListNode* slow = dummyHead; 
        while (n-- && fast != NULL){// 忘记 NULL 情况了
            fast = fast->next;
        }
        // fast首先走n + 1步，因为只有这样同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作）
        fast = fast->next;
        while (fast!= NULL){// 注意不是fast->next 因为是倒数第 N 个节点
            fast = fast->next;
            slow = slow->next;
            
        }
        slow->next = slow->next->next;
        //C++释放内存的逻辑
        //ListNode *tmp = slow->next;  
        //slow->next = tmp->next;
        //delete nth;
        return dummyHead->next;
    }
};

时间复杂度: O(n)
空间复杂度: O(1)

三、面试题 02.07. 链表相交

题目：给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
思路：就是求两个链表交点节点的指针。 这里要注意，交点不是数值相等，而是指针相等。
代码：

方法1

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0, lenB = 0;
        while (curA != NULL) { // 求链表A的长度
            lenA++;
            curA = curA->next;
        }
        while (curB != NULL) { // 求链表B的长度
            lenB++;
            curB = curB->next;
        }
        curA = headA;
        curB = headB;
        // 让curA为最长链表的头，lenA为其长度
        if (lenB > lenA) {
            swap (lenA, lenB);
            swap (curA, curB);
        }
        // 求长度差
        int gap = lenA - lenB;
        // 让curA和curB在同一起点上（末尾位置对齐）
        while (gap--) {
            curA = curA->next;
        }
        while (curA != NULL) {
            if (curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

方法2

 // 双指针法
 // 就是求两个链表交点节点的**指针**。 要注意，交点不是数值相等，而是指针相等。
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if (headA == nullptr || headB == nullptr){
            return  nullptr;
        }
        ListNode* pa = headA;
        ListNode* pb = headB;
        while ( pa != pb){
            pa = pa == nullptr ? headB : pa->next;
            pb = pb == nullptr ? headA : pb->next;
        }
        return pa;
    }
};

四、142.环形链表II

题意： 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
思路：解决两个问题
问题1. 判断链表是否环
问题2. 如果有环，如何找到这个环的入口
针对问题1，可以使用快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环。
针对问题2，是一个数学推导问题，参考详解

 // 快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点
 // 如果 fast 和 slow指针在途中相遇 ，说明这个链表有环
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while (fast != NULL && fast->next != NULL){
            slow = slow->next;
            fast = fast->next->next;
            // fast与slow相遇
            //那么相遇时： slow指针走过的节点数为: x + y,fast指针走过的节点数：x + y + n (y + z)
            if (fast == slow){
            ListNode* index1 = fast;
            ListNode* index2 = head;
                while (index1 != index2){
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2;
            }
        }
        return NULL;
    }
};

总结

除了代码能力，还需要加强数学推理能力，还需要2刷巩固，熟练掌握虚拟头节点，双指针，快慢指针，增删改查等操作。