代码随想录算法训练营D4

最新推荐文章于 2024-09-14 22:25:23 发布

AgenTGq

最新推荐文章于 2024-09-14 22:25:23 发布

阅读量2.9k

点赞数 47

分类专栏：代码随想录算法训练营文章标签：算法 leetcode c++ 学习

本文链接：https://blog.csdn.net/qq_42917527/article/details/136578121

版权

代码随想录算法训练营专栏收录该内容

15 篇文章 6 订阅

订阅专栏

D4: 最近睡眠质量突出一个差字 =。= 不知道为什么

24. Swap Nodes in Pairs

两两交换节点，重点在于一定一定要画图，不画图只会越写越乱。以及要注意循环终止的条件，要后两个节点都不为空才行。步骤图如下：

代码如下：

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* cur = dummy;
        while (cur->next != NULL && cur->next->next != NULL) {
            ListNode* first = cur->next; // 第一个被交换节点
            ListNode* second = cur->next->next; // 第二个被交换节点

            ListNode* temp = second->next;
            cur->next = second;
            second->next = first;
            first->next = temp;
            cur = first;
        }

        head = dummy->next;
        delete (dummy);
        return head;
    }
};

19.Remove Nth Node From End of List

删除链表的倒数第N个节点，一开始就想着暴力解法了，先遍历一遍求长度，然后再删掉第（size-n）个节点。后来想到了双指针法。慢指针指向链表头，快指针指向第n个节点，也就是快慢指针n步，然后快慢指针同时移动，当快指针指向链表尾的时候，慢指针的下一个节点就是要删除节点。Carl的做法是快指针移动n+1，使fast移动到Null位置，其实和这个一样的。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* slow = dummy;
        ListNode* fast = dummy;
        
        // 快指针先移动n步
        for (int i = 0; i < n; ++i) {
            fast = fast->next;
        }

        // 快慢指针同时移动，直到快指针到达末尾
        while (fast->next != nullptr) {
            slow = slow->next;
            fast = fast->next;
        }

        // 删除慢指针的下一个节点
        ListNode* toDelete = slow->next;
        slow->next = slow->next->next;
        delete toDelete;

        head = dummy->next;
        delete dummy; // 删除哑节点
        return head;
    }
};

160. Intersection of Two Linked Lists

判断链表相交，简单来说，就是求两个链表交点节点的指针。注意，交点不是数值相等，而是指针相等。

求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB 末尾对齐的位置，，然后同时移动curA和curB，两者相遇则代表链表相交。

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if (!headA || !headB) return nullptr;

        ListNode *curA = headA;
        ListNode *curB = headB;

        // 统计长度
        int sizeA = 0, sizeB = 0;
        while (curA) {
            curA = curA->next;
            sizeA++;
        }
        while (curB) {
            curB = curB->next;
            sizeB++;
        }

        // 调整起点
        curA = headA;
        curB = headB;
        if (sizeA > sizeB) {
            int gap = sizeA - sizeB;
            while (gap--) curA = curA->next;
        } else {
            int gap = sizeB - sizeA;
            while (gap--) curB = curB->next;
        }

        // 查找交点
        while (curA != curB) {
            curA = curA->next;
            curB = curB->next;
        }

        return curA;
    }
};

查找交点那里，我一开始重新创建了一个node，然后判断条件是while(curA!=NULL)，写完和这个效果一样的，但是会没有那么简洁，而且浪费空间。这里直接查curA和curB是否相等就行了，然后返回curA。

142. Linked List Cycle II

这个很好想到采用两个快慢指针判断链表是否有环。难点是如何判断环的起点以及如何证明？
当两个快慢指针相遇时，记录相遇位置，然后慢指针继续逐步移动，另取指针从起点逐步移动，两个指针重新相遇的位置就是环的起点。证明参考Carl哥的证明。
证明：
假设从头结点到环形入口节点的节点数为x。环形入口节点到 fast指针与slow指针相遇节点节点数为y。从相遇节点再到环形入口节点节点数为 z。如图所示：
在这里插入图片描述
那么相遇时： 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指针。

这个公式说明什么呢？

先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。

当 n为1的时候，公式就化解为 x = z，

这就意味着，从头结点出发一个指针，从相遇节点也出发一个指针，这两个指针每次只走一个节点，那么当这两个指针相遇的时候就是环形入口的节点。

总结：链表用两天的时间也学习完了。主要有以下重点：

虚拟头节点：虚拟头节点是在链表最开始之前额外添加的一个节点dummy，它的值通常不被使用（或者设为一个特定的默认值，主要用于简化删除和插入，避免对空链表的特殊处理，减少错误和提高代码的可读性，优化性能（也就是减少对特殊情况的判断）。
双指针法：反转链表问题，删除倒数第n个节点问题，链表相交问题，链表环问题。
链表有环的判断：判断采用快慢指针，重点是如何判断环的起点和证明，这个要会数学推导。