代码随想录算法训练营第四天|24. 两两交换链表中的节点 ；19.删除链表的倒数第N个节点 ； 面试题 02.07. 链表相交 ；142.环形链表II

于 2023-12-05 19:47:06 发布
阅读量860 收藏 12
点赞数 13
分类专栏： 算法训练 文章标签： 链表 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HY1018LY/article/details/134815662
版权

代码随想录训练营第四天|24. 两两交换链表中的节点 ；19.删除链表的倒数第N个节点 ； 面试题 02.07. 链表相交 ；142.环形链表II

[24题目链接](24. 两两交换链表中的节点 - 力扣（LeetCode）)

解题状态：已通过

我的解答：

class Solution {
public:
    ListNode* swapPairs(ListNode* head) 
    {
        if(head==nullptr)
        {
            return head;
        }
        ListNode* front = head;
        ListNode* after = head->next;
        if(after==nullptr)
        {
            return head;
        }
        while(after != nullptr)
        {
            int temp = front->val;
            front->val = after->val;
            after->val = temp;
            if(after->next!=nullptr && after->next->next!=nullptr)
            {
                front = front->next->next;
                after = after->next->next;
            }
            else
            {
                return head;
            }
        }
        return head;
    }
};

解题思路：

首先定义前后两个指针，front指向head，after指向第二个节点，当after为空时，说明链表中只有一个节点，可以直接返回头节点。当after不为空，说明链表至少存在2个节点，接着可以交换两个节点的val属性，之后对after->next和after->next->next进行检查，只有当两个都不为空时，才有可能需要我们的【交换节点】操作，交换之后，将【front】和【after】分别向后移动两个节点，执行交换操作，再对after->next和after->next->next进行判断，一直到遍历结束。【after->next】为空说明后面已经没有节点，可以返回，【after->next->next】为空，说明后面只有一个节点了，也可以直接返回。

代码随想录题解：

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
        dummyHead->next = head; // 将虚拟头结点指向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; // cur移动两位，准备下一轮交换
        }
        return dummyHead->next;
    }
};

解题思路：看到这个题解我才发现我偷懒了，我只是交换节点值 ，没有交换节点，嘻嘻~，这个解法没有什么难理解的技巧，按照步骤操作就行，可按下图来进行。

在这里插入图片描述

[题目解析](代码随想录 (programmercarl.com))

视频解析

[19-题目链接](19. Remove Nth Node From End of List - 力扣（LeetCode）)

解题状态：已通过

我的解答：

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) 
    {
        ListNode* pre = nullptr;
        ListNode* cur = head;
        int k=1;
        while(k<n)
        {
            cur = cur->next;
            k++;
        }
        pre = head;
        cur = cur->next;
        if(cur==nullptr)
        {
            return head->next;
        }
        while(cur->next!=nullptr)
        {
            pre = pre->next;
            cur = cur->next;
        }
        pre->next = pre->next->next;
        return head;
    }
};

解题思路：采用的双指针，一个前指针，一个后指针，两个指针的起点相同，我们可以先让前面的指针提前走【n-1】步，这个时候，假如前指针是最后一个节点，那我的后指针对于【前指针】来说，不就是倒数【第n个】节点吗？基于这个想法，我们就让【前指针】遍历到最后一个节点就行啦，此外，我们让前指针遍历到【需要删除节点】的前一个节点会更方便执行删除操作，所以我们会让前指针多走一步。

代码随想录题解：

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* slow = dummyHead;
        ListNode* fast = dummyHead;
        while(n-- && fast != NULL) {
            fast = fast->next;
        }
        fast = fast->next; // fast再提前走一步，因为需要让slow指向删除节点的上一个节点
        while (fast != NULL) {
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next; 
        
        // ListNode *tmp = slow->next;  C++释放内存的逻辑
        // slow->next = tmp->next;
        // delete nth;
        
        return dummyHead->next;
    }
};

解题思路：与我的解题方法一致，就不细说啦。

[题目解析](代码随想录 (programmercarl.com))

[视频解析](链表遍历学清楚！ | LeetCode：19.删除链表倒数第N个节点_哔哩哔哩_bilibili)

[面试题 02.07. 链表相交-题目链接](面试题 02.07. 链表相交 - 力扣（LeetCode）)

解题状态：已通过

我的解答：

class Solution 
{
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) 
    {
        int patha = 0;
        int pathb = 0;
        ListNode* ptr1 = headA;
        ListNode* ptr2 = headB;
        while(ptr1!=NULL)
        {
            patha++;
            ptr1 = ptr1->next;
        }
        while(ptr2!=NULL)
        {
            pathb++;
            ptr2 = ptr2->next;
        }
        if(patha==pathb)
        {
            ptr1 = headA;
            ptr2 = headB;
            while(ptr1!=NULL && ptr2!=NULL)
            {
                if(ptr1==ptr2)
                {
                    return ptr1;
                }
                ptr1 = ptr1->next;
                ptr2 = ptr2->next;
            }
            return 0;
        }
        if(patha>pathb)
        {
            int k = patha-pathb;
            ptr1 = headA;
            ptr2 = headB;
            while(k!=0)
            {
                ptr1 = ptr1->next;
                k--;
            }
            while(ptr1!=NULL && ptr2!=NULL)
            {
                if(ptr1==ptr2)
                {
                    return ptr1;
                }
                ptr1 = ptr1->next;
                ptr2 = ptr2->next;
            }
            return 0;
        }
        else
        {
            int w = pathb-patha;
            ptr1 = headA;
            ptr2 = headB;
            while(w!=0)
            {
                ptr2 = ptr2->next;
                w--;
            }
            while(ptr1!=NULL && ptr2!=NULL)
            {
                if(ptr1==ptr2)
                {
                    return ptr2;
                }
                ptr1 = ptr1->next;
                ptr2 = ptr2->next;

            }
            return 0;
        }

    }
};

解题思路：首先我们需要求出两个链表的长度。如果长度是相等的，我们用两个指针分别从两个链表头开始遍历，如果相遇了，相遇的点就是【相交点】，如果没有相遇，说明没有相交点。如果长度不相等，就让长的链表的指针先走k步（k是长度的差值），然后再让两个链表的指针同时走，如果相遇就找到了相交点，不能相遇就没有相交，因为如果存在相交点，长链表只可能在相交点前比短链表长，所以让长的链表先走k，这样长链表和短链表到相交点的节点数就是一致的。

代码随想录题解：

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0, lenB = 0;
        while (curA != NULL) { // 求链表A的长度
            lenA++;
            curA = curA->next;
        }
        while (curB != NULL) { // 求链表B的长度
            lenB++;
            curB = curB->next;
        }
        curA = headA;
        curB = headB;
        // 让curA为最长链表的头，lenA为其长度
        if (lenB > lenA) {
            swap (lenA, lenB);
            swap (curA, curB);
        }
        // 求长度差
        int gap = lenA - lenB;
        // 让curA和curB在同一起点上（末尾位置对齐）
        while (gap--) {
            curA = curA->next;
        }
        // 遍历curA 和 curB，遇到相同则直接返回
        while (curA != NULL) {
            if (curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

解题思路：与我的解法一致。

[题目解析](代码随想录 (programmercarl.com))

本题没有视频讲解

[142-题目链接](142. 环形链表 II - 力扣（LeetCode）)

解题状态：未能自己解答

代码随想录题解

class Solution {
public:
    ListNode *detectCycle(ListNode *head) 
    {
        ListNode* fast = head;
        ListNode* low = head;
        while(fast!=NULL && fast->next!=NULL)
        {
            fast = fast->next->next;
            low = low->next;
            if(fast==low)
            {
                ListNode* cur = low;
                ListNode* pre = head;
                while(cur!=pre)
                {
                    cur = cur->next;
                    pre = pre->next;
                }
                return cur;
            }
        }
        return NULL;
        
    }
};

解题思路：

在这里插入图片描述

首先我们需要知道，【怎么判断环的存在】，可以利用快慢指针，两个指针从同一节点出发，快指针每次走两个节点，慢指针每次走一个节点，如果存在环，快指针一定会先于慢指针进入环，当慢指针也进入环时，慢指针和快指针之间的关系相当于，慢指针“静止“，快指针一步一步接近慢指针，【因为慢指针一次走一步，快指针一次走两步】，所以如果存在环，他们一定会相遇。如果不存在环，则快指针就会遍历完链表，指向空。

接下来的问题就是怎么寻找环的入口：假设从头结点到环形入口节点 的节点数为x。 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。 从相遇节点 再到环形入口节点节点数为 z。那么相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。

  1. 首先解释下，为什么慢指针走的节点数目是【x+y】，当慢指针刚进入环时，快指针一定处于环的某个位置，此时在慢指针走完【一圈】之前，快指针一定会追上她（因为快指针一次走两步），所以在相遇时，慢指针不可能走完完整的一圈，所以相遇时慢指针走的节点数目时【x+y】
  2. 第二个关键，解释一下为什么快指针走过的节点数是【x + y + n (y + z)】，其中【n (y + z)】代表快指针饶环走过的节点数，还是假设第一个解释的场景，在慢指针刚进入环时，快指针处于环的某一个位置，此时，快指针一定会先走完【目前没有完成的圈】，再从环的起点开始，去追慢指针，最后相遇，所以快指针走过的节点数就是x，加上绕过的所有圈【n (y + z)】，再加上追慢指针走的节点y。

理解了以上两点，就可以建立快慢指针之间的关系了，因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：【(x + y) * 2 = x + y + n (y + z)】，通过化解之后可以得到【x = (n - 1) (y + z) + z】

注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针（可以根据第二点解释来理解，因为快指针要完成未走完的圈，再开始追）。先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。当 n为1的时候，公式就化解为 x = z，这就意味着，从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。也就是在相遇节点处，定义一个指针index1，在头结点处定一个指针index2。让index1和index2同时移动，每次移动一个节点， 那么他们相遇的地方就是 环形入口的节点。理解了思路，代码就好写了。

[题目解析](代码随想录 (programmercarl.com))

[视频讲解](把环形链表讲清楚！ 如何判断环形链表？如何找到环形链表的入口？ LeetCode：142.环形链表II_哔哩哔哩_bilibili)

HY1018LY
关注
  • 13
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值