代码随想录day04| 24.两两交换链表中的节点、19.删除链表的倒数第n个节点、链表相交、142.环形链表II

提示：DDU，供自己复习使用。欢迎大家前来讨论~

---

链表Part02

链表的进阶学习

一、题目

题目一：24. 两两交换链表中的节点

使用虚拟头结点（dummyHead），统一操作。

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummmyHead = new ListNode(0);
        dummmyHead->next = head;
        ListNode* cur = dummmyHead;
        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* result = dummmyHead->next;
        delete dummmyHead;
        dummmyHead = nullptr;
        return result;
    }
};

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

题目二：19.删除链表的倒数第N个节点

关键点在于：如何找个倒数第n个节点。

思路：

• 定义两个指针，一个fast，一个slow。连用快慢指针的差值=n。

• 单链表中删除一个节点，要知道前一个节点，所以使得差值为n+1。

• 再进行后续的删除。

注意：使用虚拟头结点，统一对头结点和非头结点的的操作

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-- && fast != nullptr) {
            fast = fast->next;
        }
        while (fast != nullptr) {
            fast = fast->next;
            slow = slow->next;
        }
        ListNode* tmp = slow->next; //记得这里内存的释放。
        slow->next = slow->next->next;
        delete tmp;

        return dummyHead->next;
    }
};

题目三：面试题 02.07. 链表相交

思路：求出两个链表的长度，然后求出两个链表的差值，然后两个链表末尾对齐，curA和curB对齐。

注意：

• 指针所指向的节点相等，不是值相等。

/**
 * 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* curA = headA;
        ListNode* curB = headB;
        int lenA = 0, lenB = 0;

        // 计算两个链表的长度；
        while (curA != NULL) {
            lenA++;
            curA = curA->next;
        }

        while (curB != NULL) {
            lenB++;
            curB = curB->next;
        }

        // 归位
        curA = headA;
        curB = headB;

        // 默认使得A链表为最长的
        if (lenB > lenA) {
            swap(curA, curB);
            swap(lenA, lenB);
        }

        // 计算两者的差值
        int gap = lenA - lenB;
        while (gap--) {
            curA = curA->next;
        }

        while (curA != NULL) {
            if (curA == curB) { // 指针对应的节点相等，不是值相等
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

• 时间复杂度: O(n+m)
• 空间复杂度: O(1）

看到另一种直接的方法，比较好理解。原文在此

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int countA = 1; int countB = 1;
        ListNode* tmpA = headA; ListNode* tmpB = headB;
        while(tmpA && tmpB){
            if(tmpA == tmpB) return tmpA;
            tmpA = tmpA -> next;
            tmpB = tmpB -> next;
            if(tmpA == NULL && countA){
                tmpA = headB;
                countA--;
            }
            if(tmpB == NULL && countB){
                tmpB = headA;
                countB--;
            }
        }
        return NULL;
    }
};                        

题目四：142.环形链表II

题目有些难，涉及到数学公式化简和条件的获得。

• 判断链表是否有环。

• 如果有环，找到环的入口。

思路：
使用快慢指针，fast每次移动两步，slow每次移动一步，如果有环，总会遇上。

那么相遇时：

• slow指针走过的节点数为: x + y，
• fast指针走过的节点数：x + y + n (y + z)，

​ n为fast指针在环内走了n圈才遇到slow指针，（y+z）为 一圈内节点的个数A。

因为fast指针是一步走两个节点，slow指针一步走一个节点，

所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：(x + y) * 2 = x + y + n (y + z)

两边消掉一个（x+y）: x + y = n (y + z)

因为要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离。

所以要求x ，将x单独放在左面：x = n (y + z) - y ,再从n(y+z)中提出一个 （y+z）来，

整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，
因为 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;

            if (slow == fast) {//相遇
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while (index1 != index2) {//找入环的点
                    index1 = index1->next;
                    index2 = index2->next;
                }

                return index1;
            }
        }
        return NULL;
    }
};

• 时间复杂度: O(n)，快慢指针相遇前，指针走的次数小于链表长度，快慢指针相遇后，两个index指针走的次数也小于链表长度，总体为走的次数小于 2n
• 空间复杂度: O(1）

---

总结

• 使用虚拟头节点，统一操作。
• 找到倒数第n个节点，利用双指针的差值。
• 了解环形链表，是否为环和找到入环的位置。（数学运算）。