Day 4 | LeetCode 刷题

题目：24 两两交换链表中的节点、19 删除链表的倒数第 N 个结点、面试题 02.07. 链表相交-同160 链表相交、142 环形链表II
打卡日期：2024.1.25、1.31

24 两两交换链表中的节点

注：做这一题的时候可以画清楚每一步的图，以理清思路，否则操作多个节点时容易混乱，并且要注意节点交换的顺序，以及需要提前定义的节点。考虑到奇数个节点和偶数个节点的链表结束条件不同，因此while循环要加上两个结束条件的限制。

思路如图：

代码如下：

/**
 * 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* dummyhead = new ListNode(0);
        dummyhead->next = head;
        ListNode* cur = head;
        ListNode* prev = dummyhead;
        // 偶数节点
        while (cur != nullptr && cur->next != nullptr) {
            ListNode* tmp = cur->next->next;    // 下一个要交换的节点
            prev->next = cur->next;
            cur->next->next = cur;  // 交换相邻节点
            cur->next = tmp;
            // 更新
            prev = cur;
            cur = tmp;
        }
        return dummyhead->next;
    }
};

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

暴力解法（扫描两趟）

遍历链表得到链表长度，将问题转化为删除正数第M个节点

/**
 * 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* dummyHead = new ListNode(0);
        dummyHead->next = head;
        // 统计链表节点个数
        ListNode* cur = head;
        int size = 0;
        while (cur != nullptr) {
            size++;
            cur = cur->next;
        }
        // 删除倒数第n个节点
        int m = size - n;   // 正数第m+1个
        ListNode* prev = dummyHead;
        cur = head;
        while (m != 0) {
            prev = cur;
            cur = cur->next;
            m--;
        }
        prev->next = cur->next;
        delete cur;
        return dummyHead->next;
    }
};

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

双指针法（扫描一趟）

双指针的经典应用，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。

/**
 * 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* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* fast = dummyHead;
        ListNode* slow = dummyHead;
        // 快指针先走n步
        while (n != 0) {
            fast = fast->next;
            n--;
        }
        // 快慢指针同时移动
        while (fast->next != nullptr) {
            slow = slow->next;
            fast = fast->next;
        }
        ListNode* tmp = slow->next;
        slow->next = slow->next->next;
        delete tmp;
        return dummyHead->next;
    }
};

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

面试题 02.07. 链表相交（同160 链表相交）

/**
 * 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) {
        ListNode* dummyHeadA = new ListNode(0);
        ListNode* dummyHeadB = new ListNode(0);
        dummyHeadA->next = headA;
        dummyHeadB->next = headB;
        ListNode* curA = dummyHeadA;
        ListNode* curB = dummyHeadB;
        ListNode* intersact = NULL; // 交点
        int sizeA = -1;
        int sizeB = -1;
        int n = 0;  // 长度差
        // 统计A、B两链表节点个数差
        while (curA != NULL) {
            curA = curA->next;
            sizeA++;
        }
        while (curB != NULL) {
            curB = curB->next;
            sizeB++;
        }
        // 快慢指针：快指针先走n步，然后快慢指针同时移动
        curA = dummyHeadA;
        curB = dummyHeadB;
        if (sizeA >= sizeB) {
            n = sizeA - sizeB;
            while (n != 0) {
                curA = curA->next;
                n--;
            }
        } else {
            n = sizeB - sizeA;
            while (n != 0) {
                curB = curB->next;
                n--;
            }
        }
        while (curA != NULL && curB != NULL) {
            if (curA == curB) {
                intersact = curA;
                break;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return intersact;
    }
};

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

142 环形链表II

这道题主要考察两个点：

• 判断链表是否有环
• 若有环，如何找到环的入口

问题一：判断链表是否有环
可以使用快慢指针法，快指针每次前进两步，慢指针前进一步（即相对于慢指针快指针每次靠近一步），故若有环，则快慢指针一定能在途中相遇

问题二：若有环，如何找到环的入口

相遇时，记：

• slow指针走过的节点数为 $x+y$
• 则fast指针走过的节点数为 $x+y+n\ast (y+z)$
• ∵ fast指针走过的总节点数是slow指针两倍，可列式：
  • $x+y+n\ast (y+z)=2\ast (x+y)$
  • 确定环的入口即确定 $x$ 处节点，故变形为 $x=(n-1)\ast (y+z)+z，n$ 为正整数
  • 最后等式的物理意义是 index1从头结点出发（x），index2节点从相遇点出发（z+(n-1)*(y+z)），它们同时前移，会在环的入口处相遇，该相遇点就是环的入口

双指针法

/**
 * 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 != NULL && fast->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast) { // 相遇
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while (index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2;  // 返回入口
            }
        }
        return NULL;
    }
};