代码随想录算法训练营Day4（LeetCode24 两两交换链表中的节点；LeetCode19 删除链表的倒数第N个节点；面试题02.07 链表相交；LeetCode142 环形链表II）

LeetCode24 两两交换链表中的节点

题目链接：两两交换链表中的节点(https://leetcode.cn/problems/swap-nodes-in-pairs/description/)
文档讲解：代码随想录(https://programmercarl.com)

做题情况

这道题直接写出来了，但是一开始用了很多指针，用于表达 curNode 和 curNode->next 和 curNode->next->next ，反而使得我对指针为空的判断变得更加复杂了，看了代码随想录发现只需要一个 curNode 变量，这样反而将为空判断全部放到 while循环的判断式 了，方便很多。

下面是代码：

ListNode* swapPairs(ListNode* head) {
    ListNode* dummyHead = new ListNode();
    dummyHead->next = head;
    ListNode* cur = dummyHead;
    
    while (cur->next != nullptr && cur->next->next != nullptr) {
        ListNode* tmp = cur->next;
        ListNode* tmp1 = cur->next->next->next;
        cur->next = cur->next->next;
        cur->next->next = tmp;
        cur->next->next->next = tmp1;

        cur = cur->next->next;
    }

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

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

题目链接：删除链表的倒数第N个节点(https://leetcode.cn/problems/remove-nth-node-from-end-of-list/description/)
文档讲解：代码随想录(https://programmercarl.com)

做题情况

这道题需要使用双节点，遍历一遍就可以了。我在做的时候，第一次返回了 head ，但是这个节点可能被删除了，因此需要返回 dummyHead->next 才对。

下面是代码：

ListNode* removeNthFromEnd(ListNode* head, int n) {
    ListNode* dummyHead = new ListNode();
    dummyHead->next = head;
    ListNode* fastNode = dummyHead;
    ListNode* slowNode = dummyHead;
    for (int i = 0; i < n; i++) {
        fastNode = fastNode->next;
    }
    while (fastNode->next) {
        fastNode = fastNode->next;
        slowNode = slowNode->next;
    }
    ListNode* tmp = slowNode->next;
    slowNode->next = tmp->next;

    ListNode* res = dummyHead->next;
    delete dummyHead;
    delete tmp;
    return res;
}

面试题02.07 链表相交

题目链接：链表相交(https://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/description/)
文档讲解：代码随想录(https://programmercarl.com)

做题情况

这道题不难但是还是看了题解思路才写出来的，而且有一些冗余变量。比如 shortNode 和 longNode 完全可以通过 curA 和 curB 的交换来减少，这里的细节还需要注意。

以下是代码：

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
    ListNode* dummyNodeA = new ListNode(0);
    dummyNodeA->next = headA;
    ListNode* dummyNodeB = new ListNode(0);
    dummyNodeB->next = headB;

    ListNode* curA = dummyNodeA;
    ListNode* curB = dummyNodeB;
    int sizeA = 0;
    int sizeB = 0;
    while (curA->next) {
        sizeA++;
        curA = curA->next;
    }
    while (curB->next) {
        sizeB++;
        curB = curB->next;
    }

    ListNode* longNode;
    ListNode* shortNode;
    if (sizeA < sizeB) {
        shortNode = dummyNodeA;
        longNode = dummyNodeB;
        for (int i = 0; i < sizeB - sizeA; i++) {
            longNode = longNode->next;
        }
    }
    else {
        shortNode = dummyNodeB;
        longNode = dummyNodeA;
        for (int i = 0; i < sizeA - sizeB; i++) {
            longNode = longNode->next;
        }
    }

    while (shortNode != nullptr && longNode != nullptr) {
        if (shortNode == longNode) {
            return longNode;
        }
        shortNode = shortNode->next;
        longNode = longNode->next;
    }
    return nullptr;       
}

LeetCode142 环形链表II

题目链接：环形链表II(https://leetcode.cn/problems/linked-list-cycle-ii/description/)
文档讲解：代码随想录(https://programmercarl.com)

做题情况

这道题看了题解，关键在于要理解第一次相遇时， slow 是环中的第一圈。

以下是代码：

ListNode *detectCycle(ListNode *head) {
    ListNode* dummyHead = new ListNode(0);
    dummyHead->next = head;

    ListNode* fast = dummyHead;
    ListNode* slow = dummyHead;
    while (fast->next != nullptr && fast->next->next != nullptr) {
        fast = fast->next->next;
        slow = slow->next;

        if (fast == slow) {
            ListNode* index1 = dummyHead;
            ListNode* index2 = fast;
            while (index1 != index2) {
                index1 = index1->next;
                index2 = index2->next;
            }
            return index1;
        }
    }
    return nullptr;
}