Day.4 | 24. 两两交换链表中的节点 19.删除链表的倒数第N个节点 160.链表相交 142.环形链表II

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

要点：首先这必然是一个循环，所以确定循环的起点终点，以及每次循环需要处理的元素即可解决问题，画一个链表，多连几次循环操作即可发现规律

方法：

循环起点：虚拟头节点

循环终点：（双数）cur->next == nullptr （单数） cur->next->next == nullptr

循环步长：每次移动两个节点

循环操作：A -> B -> C -> D 每次操作涉及4个节点

        1. A -> next 改为 A -> C

        2. C -> next 改为 C -> B

        3. B -> next 改为 B -> D

        如果在操作时发现有节点找不到，在操作前用临时变量保存下来即可

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* tempNode1 = cur->next;
            ListNode* tempNode2 = cur->next->next->next;
            cur->next = cur->next->next;
            cur->next->next = tempNode1;
            cur->next->next->next = tempNode2;

            cur = cur->next->next;
        }

        ListNode* result = dummyHead->next;
        delete dummyHead;
        return result;
    }
};

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

要点：快慢指针，或者说前后指针，画图多画几次就能理解为什么快指针要多走一步

删除倒数第n个节点，就是让快慢指针之间间隔（n-1）个节点，快指针先走n步，然后再多走一步

如果不多走这一步，快指针到链表末尾的时候，慢指针刚好到要删除的节点，但是如果要删除一个节点，只能操作这个节点的前一个节点，所以快指针要多走一步

方法：

1. 虚拟头结点

2. 快慢指针

3. 快指针走n步，然后再多走一步

4. 快慢指针一起走，直到快指针到链表末尾

5. 修改此时慢指针的next，删除节点

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 != nullptr) {
            fast = fast->next;
        }
        fast = fast->next;
        while (fast != nullptr) {
            slow = slow->next;
            fast = fast->next;
        }
        slow->next = slow->next->next;
        ListNode* result = dummyHead->next;
        delete dummyHead;
        return result;
    }
};

160.链表相交

要点：首先，题目给的就是一个相交的链表，输入是这个相交链表的两个头，从交点开始往后，就是同一个内存地址同一个对象，所以要找一个方法，遍历给出的两个头节点，看从什么时候开始，能找到一样的内存地址，那么就是有交点的

方法：

1. 当成是两个链表，遍历两个头，求两个链表的长度

2. 如果有交点，那从尾巴到交点处，两个链表肯定是一样的，那么把这两个链表从尾部对齐

3. 先遍历长的链表，直到剩余长度跟短链表相等

4. 同时遍历长短链表，直到找到两个链表的遍历指针相等的时候

class Solution {
public:
    ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0, lenB = 0;
        while (curA != nullptr) {
            lenA++;
            curA = curA->next;
        }
        while (curB != nullptr) {
            lenB++;
            curB = curB->next;
        }
        curA = headA;
        curB = headB;
        if (lenB > lenA) {
            swap(lenA, lenB);
            swap(curA, curB);
        }
        int gap = lenA - lenB;
        while (gap--) {
            curA = curA->next;
        }
        while (lenB--) {
            if (curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return nullptr;
    }
};

142.环形链表II

要点：感觉这个题的解法很特殊，没什么适用性也没什么有助于理解链表这个数据结构的地方。如果真要是工作上碰到这种场景，我应该会直接暴力存下所有指针的地址，用查表法确定是否有环以及环的入口位置在哪里。这个题就先不做深入理解了

方法：

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;
            // 快慢指针相遇，此时从head 和 相遇点，同时查找直至相遇
            if (slow == fast) {
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while (index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2; // 返回环的入口
            }
        }
        return NULL;
    }
};