「使用双指针技巧解决一些链表的问题」

最新推荐文章于 2023-09-15 21:17:33 发布
最新推荐文章于 2023-09-15 21:17:33 发布
阅读量457 收藏 1
点赞数
分类专栏： LeetCode 文章标签： 链表 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44673253/article/details/126508527
版权

文章目录

141. 环形链表

在这里插入图片描述

题解

使用双指针，一个快指针，一个慢指针，快指针fast一次走两步，而慢指针slow一次走一步，看会不会碰到，碰到了就说明有环。

Code

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        if (head == nullptr) return head;
        ListNode *fast = head, *slow = head;
        while (fast != nullptr && fast->next != nullptr)//走两步的指针都要看这个fast->next是否为空
        {
            fast = fast->next->next;
            slow = slow->next;
            if (fast == slow) return true;
        }
        return false;
    }
};

结果

在这里插入图片描述

142. 环形链表 II

在这里插入图片描述

题解

还是使用双指针，一个快一个慢，当两个指针相遇碰到的时候，跳出循环，此时两个指针是相遇的时候跳出了循环，此时让slow = head，然后此时fast和slow再一起移动，再次相遇的时候，就是环的起点。

Code

/**
 * 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) {
        if (head == nullptr) return head;
        ListNode *fast = head, *slow = head;
        while (fast != nullptr && fast->next != nullptr)
        {
            fast = fast->next->next;
            slow = slow->next;
            if (fast == slow) break;
        }

        //判断是while循环跳出，还是if中的break跳出
        if (fast == nullptr || fast->next == nullptr) return nullptr;//说明没有环

        //如果不是从while中跳出，说明是从if跳出，此时是两者进入了相交点
        slow = head;//令solw = head，这时候，再让fast和slow同时走，再次相遇的点，就是环的起点
        while (fast != slow)
        {
            fast = fast->next;
            slow = slow->next;
        }
        return slow;
    }
};

结果

在这里插入图片描述

160. 相交链表

在这里插入图片描述

题解

如何判断两个链表是否相交？我们可以让两个链表的长度相等，当到达相交节点的时候返回，那如何让两个长度不等的链表长度相等？可以等A跑完，再让A接着B跑，B跑完再让B接着A跑，就可以达到目的。

Code

/**
 * 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 *p1 = headA, *p2 = headB;
        while (p1 != p2)
        {
            if (p1 == nullptr) p1 = headB;
            else p1 = p1->next;
            if (p2 == nullptr) p2 = headA;
            else p2 = p2->next;
        }
        return p1;//相交的时候，就返回相交节点，p1或者p2都可以；不想交的时候，直到p1或p2都为空，跳出循环后，p1 = p2 =nullptr，返回空节点。
    }
};

结果

在这里插入图片描述

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

在这里插入图片描述

题解

删除倒数第n个节点，也就是删除正数第m-n+1个节点，m代表总的节点数，还是利用双指针，利用以上规律，先找到倒数第n+1个节点，找到后，进行删除倒数第n个。

Code

/**
 * 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* find(ListNode* head, int n)
    {
        ListNode *p1 = head;//采用双指针，p1先向前走n步
        for (int i = 0; i < n; ++i)
        {
            p1 = p1->next;
        }
        ListNode *p2 = head;
        //此时p2在第一个节点位置，此时p1已经走完n步了，现在让p1 p2同时开始走步，走m-n步即可。
        while (p1 != nullptr)
        {
            p2 = p2->next;
            p1 = p1->next;
        }
        //此时p2的位置，即为正数的m-n+1位置
        return p2;
    }

    ListNode* removeNthFromEnd(ListNode* head, int n) {
        //删除倒数第n个节点，也就是整数第m-n+1个节点，m是节点总数
        ListNode* dummy = new ListNode(-1);//引入dummy是为了防止出现空指针的问题，
        //比如说，就只有一个节点，但是需要删除倒数n+1的节点，也就是倒数第2的节点
        //一个节点拿来倒数第二的节点呢？所以引入虚拟头结点就很好地解决了这个问题
        dummy->next = head;
        ListNode *x = find(dummy, n+1);//找到倒数第n+1个节点
        x->next = x->next->next;
        return dummy->next;
    }
};

结果

在这里插入图片描述

21. 合并两个有序链表

在这里插入图片描述

题解

两个链表从表头开始从左至右依次进行比较，再结合虚拟头结点，使两个链表合并。

Code

/**
 * 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* mergeTwoLists(ListNode* list1, ListNode* list2) {
        //大概思路，虚拟哨兵头结点以及这个双指针的框架
        ListNode* dummy = new ListNode(-1);
        ListNode* p = dummy;
        ListNode *p1 = list1, *p2 = list2;
        while (p1 != nullptr && p2 != nullptr)
        {
            if (p1->val > p2->val)
            {
                p->next = p2;
                p2 = p2->next;
            }
            else
            {
                p->next = p1;
                p1 = p1->next;
            }
            p = p->next;//指针向后移动
        }
        //假如最后还有两链表还有剩余
        if (p1 != nullptr)
        {
            p->next = p1;
        }
        if (p2 != nullptr)
        {
            p->next = p2;
        }
        return dummy->next; 
    }
};

结果

在这里插入图片描述

23. 合并K个升序链表

在这里插入图片描述

题解

就是刚刚的合并两个的升级版，嵌套一个for循环，来进行合并。

Code

/**
 * 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* mergeTwoLists(ListNode *a, ListNode *b)//通过构造每两个节点进行交换，推广到k个节点进行交换
    {
        if ((!a) || (!b)) return a?a:b;
        ListNode *dummy = new ListNode(-1);
        ListNode *p = dummy, *aPtr = a, *bPtr = b;
        while (aPtr && bPtr)
        {
            if (aPtr->val < bPtr->val)
            {
                p->next = aPtr;
                aPtr = aPtr->next;
            }
            else
            {
                p->next = bPtr;
                bPtr = bPtr->next;
            }
            p = p->next;
        }
        if (aPtr == nullptr)
        {
            p->next = bPtr;
        }
        if (bPtr == nullptr)
        {
            p->next = aPtr;
        }
        return dummy->next;
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode *ans = nullptr;
        for (size_t i = 0; i < lists.size(); ++i)//用个for循环，对每两个链表进行比较，这样就可以构造一个递增的序列
        {
            ans = mergeTwoLists(ans, lists[i]);
        }
        return ans;
    }
};

结果

在这里插入图片描述

86. 分隔链表

在这里插入图片描述

题解

生成两个链表，一个小于x的，一个大于等于x的，接着再用上面合并两个链表的技术，进行合并这两个链表。

Code

/**
 * 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* partition(ListNode* head, int x) {
        //思路就是弄两个小链表，有什么作用呢？
        //这两个小链表，分别存放的是小于小于x的数，另一个存放的是大于等于x的数，最后将两个链表合并（参考第21题合并链表）
        //两个小链表就有两个虚拟头节点（哨兵）
        ListNode* dummy1 = new ListNode(-1);
        ListNode* dummy2 = new ListNode(-1);
        //双指针
        ListNode* p1 = dummy1;
        ListNode* p2 = dummy2;
        ListNode* p = head;
        ListNode* temp;

        while (p != nullptr)
        {
            if (p->val >= x)
            {
                p2->next = p;
                p2 = p2->next;
            }
            else
            {
                p1->next = p;
                p1 = p1->next;
            }
            //因为直接在原链表上操作，需要断开原链表中的每个节点的next指针，防止访问出错，因为不知道p指向哪里了
            temp = p->next;
            p->next = nullptr;
            p = temp;
        }

        //分解完后，开始整合
        p1->next = dummy2->next;

        return dummy1->next;
    }
};

结果

在这里插入图片描述

876. 链表的中间结点

在这里插入图片描述

题解

有两种方法，一种是直接遍历两次，一次记录总节点数，一次到节点数/2的地方break；还有一种方法有点巧妙，双指针，快慢指针，fast走两步，slow走一步，然后fast走完，slow刚好是中点，而且，当节点数为偶数的时候，slow也是第二个中点。

Code

/**
 * 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* middleNode(ListNode* head) {
        ListNode* node = head;
        ListNode* low = head;
        if (head == nullptr) return head;
        int sum = 0, count = 0;
        while (node != nullptr)
        {
            node = node->next;
            ++sum;
        }
        while (count != sum / 2)    //使用两次循环判断
        {
            low = low->next;
            ++count;
        }
        return low;
    }
};

/**
 * 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* middleNode(ListNode* head) {
        //一样是采用双指针的技巧，设置fast还有slow这两个指针
        //fast一次走两步，slow一次走一步
        //当fast走到最后，slow刚好走到中点位置
        //同时，当节点数为偶数，slow也是刚好停到中间两节点第二个的那一个节点上
        if (head == nullptr)
        {
            return head;
        }
        ListNode *fast, *slow;
        fast = head;
        slow = head;
        while (fast != nullptr && fast->next != nullptr)
        {
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }
};

结果

在这里插入图片描述

在这里插入图片描述
两次遍历要慢一点。

世界仙境与冷酷尽头
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表双指针
qq_44819554的博客
02-22 400
链表双指针常见的题目有合并k个有序链表、判断链表中是否有环、如果有环返回第一个入环结点、是否相交链表、链表的中间结点、K个一组翻转链表、删除排序链表中重复的元素、反转链表、回文链表等，其中最长考的就是反转链表（全部反转，部分翻转），又分为递归实现和迭代实现。
链表之双指针（快慢指针，先后指针，首尾指针）
weixin_51818357的博客
07-04 1510
链表之双指针（快慢指针，先后指针）
链表双指针问题
qq_43533956的博客
03-04 687
让我们从一个经典问题开始：给定一个链表，判断链表中是否有环。 想象一下，有两个速度不同的跑步者。如果他们在直路上行驶，快跑者将首先到达目的地。但是，如果它们在圆形跑道上跑步，那么快跑者如果继续跑步就会追上慢跑者。 这正是我们在链表中使用两个速度不同的指针时会遇到的情况： 如果没有环，快指针将停在链表的末尾。 如果有环，快指针最终将与慢指针相遇。 一般来说我们把快指针的速度设为2，慢指针设为1。 求环形链表的入环点 问题描述：给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如
链表中的双指针问题
EnemyGodlike的博客
12-04 504
倒数第k个元素的问题 class Solution { public: ListNode* getKthFromEnd(ListNode* head, int k) { ListNode *p = head, *q = head; //初始化 while(k--) { //将 p指针移动 k 次 p = p->next; } while(p != nullptr) {//同时移动，直到 p ==
双指针问题
qq_40142361的博客
08-06 101
常见题型有哪些？ 这里我将其分为三种类类型，分别是： 快慢指针（两个指针步长不同，一个步长大，一个步长小。典型的是一个步长为 1，另外一个步长为 2） 左右端点指针（两个指针分别指向头尾，并往中间移动，步长关系不确定） 固定间距指针（两个指针间距相同，步长相同） 快慢指针 判断链表是否有环 1）例题：力扣 287 题，一个是 142 题。 2）读写指针。典型的是删除重复元素 例题：80.删除排序数组中的重复项 II 3）一次遍历（One Pass）求链表的中点 具体算法是使用两个指针。快
适合小白的python算法-双指针问题
12-21
总的来说，双指针和二分法是解决算法问题的有力工具，而链表作为重要的数据结构，理解其工作原理和操作方式对于提升编程能力至关重要。通过学习这些基础知识，初学者能够逐步掌握更复杂的算法问题。
java双指针和数组.zip
01-14
Java双指针是一种在数组或列表中高效解决问题的算法技巧，常常用于排序、查找、合并等操作。在处理数组问题时，双指针通常是指在数组的两端或某两个特定位置上设置两个指针，然后根据问题需求进行移动，以此来达到...
leetcodepushfront-LinkedList-DoublePointers:链表和双指针技巧的使用
07-07
判断一个链表中是否有环，可以使用双指针技巧解决。一个安全的选择是每次移动慢指针一步，而移动快指针两步。每一次迭代，快速指针将额外移动一步。如果环的长度为 M，经过 M 次迭代后，快指针肯定会多绕环一周，并...
【双指针】–leetcode(141)–给定一个链表，判断链表中是否有环(python版)
12-20
总结起来，解决链表环检查的问题，双指针技术是一种有效且直观的方法，它可以优雅地处理这类问题，避免了深度优先搜索或回溯等可能导致额外时间和空间复杂度的策略。通过理解和熟练运用这种技巧，可以提升我们在解决...
双指针算法经典问题详解
最新发布
01-14
《双指针算法经典问题详解资料，包含代码实现》是一本针对双指针算法在经典问题中的...这些代码示例不仅展示了如何使用双指针算法解决问题，还注重代码的可读性和可扩展性，帮助读者在实际开发中更好地应用双指针算法。
关于链表添加的双指针问题
weixin_48040553的博客
09-13 227
在学习链表的时候，往链表里添加新节点的时候，会运用到双指针。这是因为考虑到空链表的情况下，所做的一个特殊处理。 这里的空链表画上重点，待会会考 首先附上添加新节点的函数代码： void Attach(ListNode ** pHead, int value) { ListNode * new_Node = new ListNode(); new_Node->val = value; new_Node->next = NULL; if (*pHead == NULL) { *pHe
双指针解决链表相关问题
qq_46521280的博客
09-15 100
链表有环：指的是从链表中的头节点开始，不断地连续访问指针，可以访问到某个节点多次。
双指针解决链表常见问题
weixin_45913125的博客
05-11 387
双指针解决链表常见问题获取倒数第k个元素获取中间位置的元素判断链表是否存在环，判断环的长度 获取倒数第k个元素 设有两个指针 p 和 q，初始时均指向头结点。首先，先让 p 沿着 next 移动 k 次。此时，p 指向第 k+1个结点，q 指向头节点，两个指针的距离为 k 。然后，同时移动 p 和 q，直到 p 指向空，此时 q 即指向倒数第 k 个结点。 ListNode *p = head, *q = head; while(k--) { //将p指针移动 k 次 p = p->next;
双指针 Double Pointer
yake1965
10-07 730
88. 合并两个有序数组 125. 验证回文串 141. 环形链表 167. 两数之和 II - 输入有序数组 202. 快乐数 283. 移动零 27. 移除元素
算法：双指针
uncle_ll的博客
03-05 6679
双指针 双指针是一种思想或一种技巧并不是特别具体的算法。 具体就是用两个变量动态存储两个结点，来方便我们进行一些操作。通常用在线性的数据结构中。 特别是链表类的题目，经常需要用到两个或多个指针配合来记忆链表上的节点，完成某些操作。 常见的双指针方式 同速指针：链表上两个指针，一个先出发，另一个后出发并以相同的速度跟随。 求链表的逆：通过临时指针让双指针同步前行 求链表倒数第k个元素：先让其中一个指针向前走k步，接着两个指针以同样的速度一起 向前进，直到前面的指针走到尽头了，则后面的指针即为倒数第k个元
双指针、多指针
nameofcsdn的博客
04-12 1900
一，双指针 有很多完全不同的题目，根据他们的解法，都可以归结为双指针的题目。 大概模型： 用指针1扫描数组1，指针2扫描数组2，两个指针一起扫描，每次只有1个指针往后挪，每次挪哪个取决于数组的值和要求的目标， 当2个数组都扫描完（有的问题是只需要一个数组扫描完）时，要求的目标就求出来了。 代码特性： 双指针的代码往往是两层循环，虽然实际只是线性扫描，但是如果写错了就可能变成暴力，甚至死循环。 二，非遗忘算法 参考《算法导论》中遗忘比较交换算法https://blog.csdn...
手撕面试算法题必备技巧(贰) —— 双指针(链表篇)
东
05-10 1085
本文介绍了双指针技巧在链表、数组以及字符串中的使用，给出了大量大厂常见面试手撕题目的思路及代码，不仅适合完全不了解双指针技巧的读者，也适合老司机复习拓展。 考察过该技巧的公司有阿里巴巴、腾讯、美团、拼多多、百度等大厂。 我相信，友好的讨论交流会让彼此快速进步！文章难免有疏漏之处，十分欢迎大家在评论区中批评指正。
指针 && 双指针
weixin_34001430的博客
09-19 161
指针是C语言中的难点，C++中自然也免不了其身影。 以下是我学习中的积累，不足之处望不吝赐教。 指针类型： 指针 Constint*pstr 　　　 不能修改被指向的对象,可以使指针指向其他对象 　　如：const int* pvalue {&value}; 　　*pvalue=6;　　　　 //will not compile 　　pvalue=nullptr;　　//...
【链表】(二) 双指针技巧
闻韶
07-14 722
LeetCode - 探索卡片 - 链表 - 二 - 双指针技巧
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值