【链表】相关类型题目整理[三]

于 2021-05-31 18:38:52 发布
阅读量226 收藏
点赞数
分类专栏： 刷题笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdn_edition/article/details/117413482
版权

文章目录

一、力扣141. 环形链表

  • 给定一个链表，判断链表中是否有环。
  • 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
  • 注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
  • 如果链表中存在环，则返回 true 。 否则，返回 false 。
  • 进阶：你能用 O(1)（即，常量）内存解决此问题吗？

在这里插入图片描述
在这里插入图片描述

（一）快慢指针----空间复杂度O(1)

  • 思路：
  • 定义两个指针，分别为快慢指针；
  • 让慢指针一次走一步，而快指针一次走两步；
  • 如果链表存在还，那么最后快慢指针肯定会在环中相遇；
  • 所以如果快慢两个指针相遇了就说明该链表有环；
  • 否则如果快指针先走到nullptr，那么就说明该链表无环。
  • 代码如下：
bool hasCycle(ListNode* head) 
{
    if (head == nullptr || head->next == nullptr)
    {
        return false;
    }

    ListNode* slow = head;
    ListNode* fast = head->next;

	//为了能进入第一次循环，所以将快指针指向了头节点的下一个节点
    while (slow != fast)
    {
        if (fast == nullptr || fast->next == nullptr)
        {
            return false;
        }
        slow = slow->next;
        fast = fast->next->next;
    }
    return true;
}

（二）哈希表----空间复杂度O(N)

  • 思路：
  • 我们可以将链表中每个节点的访问次数记录下来，看会不会有出现访问量大于一次的；
  • 如果出现，则说明该链表有环；
  • 如果没有出现，就说明该链表无环。
  • 代码如下：
bool hasCycle(ListNode* head)
{
    if (head == nullptr || head->next == nullptr)
    {
        return false;
    }

    unordered_map<ListNode*, int> hash;

    ListNode* phead = head;
    while (phead != nullptr)
    {
        hash[phead]++;
        if (hash[phead] > 1)
        {
            return true;
        }
        phead = phead->next;
    }
    return false;
}

二、力扣142. 环形链表 II

  • 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
  • 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。
  • 说明：不允许修改给定的链表。
  • 进阶：你是否可以使用 O(1) 空间解决此题？
  • 输入输出示例：

在这里插入图片描述

在这里插入图片描述

（一）哈希表----空间复杂度O(N)

  • 跟上个题目一样：
  • 当我们用哈希表记录访问过的节点的次数时，只要找到第一个被访问了两次的节点，就找到了链表入环的第一个节点。
  • 代码如下：
ListNode* detectCycle(ListNode* head) 
{
    if (head == nullptr || head->next == nullptr)
    {
        return nullptr;
    }

    unordered_map<ListNode*, int> hash;

    ListNode* phead = head;
    while (phead != nullptr)
    {
        hash[phead]++;
        if (hash[phead] > 1)
        {
            return phead;
        }
        phead = phead->next;
    }
    return nullptr;
    
}

（二）快慢指针----空间复杂度O(1)

  • 思路也是和第一个题一样，关键点就在于如何找到链表的入环节点【如果链表存在环，在快慢指针第一次相遇的地方，让一个指针从head开始走，一次走一步，另一个指针从第一次相遇点开始走，一次走一步，当两个指针第一次相遇时，相遇的节点就是链表的入环节点，具体原因在代码后面会有解释】。
  • 代码如下：
ListNode* detectCycle(ListNode* head)
{
    if (head == nullptr || head->next == nullptr)
    {
        return nullptr;
    }

    //定义快慢指针
    ListNode* slow = head;
    ListNode* fast = head;

    //找到快慢指针第一次相遇的点
    while (fast != nullptr)
    {
        slow = slow->next;
        if (fast->next == nullptr)
        {
            return nullptr;
        }
        fast = fast->next->next;
        if (slow == fast)//找到第一次相遇的点
        {
            slow = head;
            while (slow != fast)
            {
                slow = slow->next;
                fast = fast->next;
            }
            return slow;//找到入环的节点
        }
    }
    return nullptr;
}
  • 如下图所示，设链表中环外部分的长度为 a。slow 指针进入环后，又走了 b 的距离与 fast 相遇。此时，fast 指针已经走完了环的 n 圈，因此它走过的总距离为 a+n(b+c)+b=a+(n+1)b+nc；

在这里插入图片描述

  • 任意时刻，fast 指针走过的距离都为 slow 指针的 2 倍；
  • 因此得出：a+(n+1)b+nc=2(a+b)⟹a=c+(n−1)(b+c)
  • 有了 a=c+(n-1)(b+c)的等量关系，我们会发现：从相遇点到入环点的距离加上 n−1 圈的环长，恰好等于从链表头部到入环点的距离。

三、面试题02.08. 环路检测

  • 给定一个链表，如果它是有环链表，实现一个算法返回环路的开头节点。
  • 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
  • 输入输出示例：

在这里插入图片描述
在这里插入图片描述

（一）哈希表

  • 思路以及代码都和环形链表II一样，在这里笔者就是为了加深对这道题的印象以及解法，相当于做了两遍⑧~踏实
  • 代码：
ListNode* detectCycle(ListNode* head) 
{
    if (head == nullptr || head->next == nullptr)
    {
        return nullptr;
    }

    unordered_map<ListNode*, int> hash;
    ListNode* phead = head;

    while (phead != nullptr)
    {
        hash[phead]++;
        if (hash[phead] > 1)
        {
            return phead;
        }
        phead = phead->next;
    }
    return nullptr;
}

（二）快慢指针

  • 代码如下：
ListNode* detectCycle(ListNode* head)
{
    if (head == nullptr || head->next == nullptr)
    {
        return nullptr;
    }

    ListNode* slow = head;
    ListNode* fast = head;

    while (fast != nullptr)
    {
        slow = slow->next;
        if (fast->next == nullptr)
        {
            return nullptr;
        }
        fast = fast->next->next;
        if (slow == fast)
        {
            slow = head;
            while (slow != fast)
            {
                slow = slow->next;
                fast = fast->next;
            }
            return slow;
        }
    }
    return nullptr;
}

四、力扣160. 相交链表

  • 编写一个程序，找到两个单链表相交的起始节点。
  • 如下面的两个链表：

在这里插入图片描述

  • 在节点 c1 开始相交。
  • 输入输出示例：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  • 提示：

在这里插入图片描述

（一）哈希表

  • 思路：
  • 首先可以先遍历其中的一个链表；
  • 然后将链表中的节点存放在哈希表中；
  • 接着再从头开始遍历另外一个链表；
  • 一边遍历一边查看该节点有没有在链表中出现过；
  • 如果出现过直接返回该节点；
  • 如果没有出现过就继续遍历，直到链表结尾。
  • 代码如下：
ListNode* getIntersectionNode(ListNode* headA, ListNode* headB)
{
    if (headA == nullptr || headB == nullptr)
    {
        return nullptr;
    }

    unordered_map<ListNode*, int> hash;

    ListNode* pheada = headA;
    ListNode* pheadb = headB;

    while (pheada != nullptr)
    {
        hash[pheada]++;
        pheada = pheada->next;
    }

    while (pheadb != nullptr)
    {
        if (hash.find(pheadb) != hash.end())
        {
            return pheadb;
        }
        else
        {
            pheadb = pheadb->next;
        }
    }
    return nullptr;
}
  • 这种解法的时间复杂度为O(N+M)，空间复杂度为O(N)或者O(M)。
  • 注意：两个链表相交以后一定是合并成一条链表了，不可能出现交叉之后又分离的情况；
  • 如下图所示：

在这里插入图片描述
在这里插入图片描述

（二）暴力的双重循环

  • 双重循环的思路也是平常做题常用到的，也很容易想到：
  • 就是将一个链表中的每个节点都与另一个链表中的节点比较，看是不是同一个节点；
  • 如果是则返回该节点，如果不是，则继续遍历直到链表结尾。
  • 代码如下：
ListNode* getIntersectionNode(ListNode* headA, ListNode* headB)
{
    if (headA == nullptr || headB == nullptr)
    {
        return nullptr;
    }

    ListNode* pheada = headA;

    while (pheada != nullptr)
    {
        ListNode* pheadb = headB;
        while (pheadb != nullptr)
        {
            if (pheada == pheadb)
            {
                return pheada;
            }
            else
            {
                pheadb = pheadb->next;
            }
        }
        pheada = pheada->next;
    }

    return nullptr;
}
  • 该种解法的时间复杂度为O(N*M)，空间复杂度为O(1)。

（三）双指针遍历

  • 思路如下图所示：

在这里插入图片描述

  • 1、先构建两个指针A和B指向链表A的头节点和链表B的头节点
  • 2、指针A先遍历完A链表再遍历B链表所走过的节点数为a+(b-c)
  • 3、指针B先遍历完B链表再遍历A链表所走过的节点数为b+(a-c)
  • 4、两个指针所走过的节点数都相同
  • 所以当c>0时，链表有公共尾部，指针A和B同时指向第一个公共节点
  • 当 c = 0 时，链表没有公共尾部，指针A和B同时为nullptr
  • 代码如下：
ListNode* getIntersectionNode(ListNode* headA, ListNode* headB)
{
    ListNode* pheada = headA;
    ListNode* pheadb = headB;

    while (pheada != pheadb)
    {
        pheada = pheada != nullptr ? pheada->next : headB;
        pheadb = pheadb != nullptr ? pheadb->next : headA;
    }

    return pheada;
}

五、力扣328. 奇偶链表

在这里插入图片描述

（一）分离节点之后再合并

  • 思路：
  • 将奇数位上的节点连接到奇链表上；
  • 将偶数位上的节点连接到偶链表上；
  • 然后再将两个链表合并起来即可
  • 具体过程如下图所示：

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

  • 代码如下：
ListNode* oddEvenList(ListNode* head) 
{
    if (head == nullptr || head->next == nullptr || head->next->next == nullptr)
    {
        return head;
    }
    ListNode* odd = head;//奇链表的头节点
    ListNode* even = head->next;//偶链表的头节点
    ListNode* evenHead = even;

    while (even != nullptr && even->next != nullptr)
    {
        odd->next = even->next;
        odd = odd->next;
        even->next = odd->next;
        even = even->next;
    }
    odd->next = evenHead;
    return head;
}

六、力扣234. 回文链表

在这里插入图片描述

（一）利用栈来作辅助

  • 首先，简单来说，回文链表就是链表的节点值倒着读和顺着读都一样；
  • 因此我们可以利用栈先进后出的特点来和原来链表的节点值做一个比对；
  • 看看是否将链表反过来之后他们的每个节点对应的val是否相等。
  • 思路也比较简单：代码如下所示
bool isPalindrome(ListNode* head) 
{
    if (head == nullptr || head->next == nullptr)
    {
        return true;
    }

    ListNode* phead = head;
    stack<int> st;

    while (phead != nullptr)
    {
        st.push(phead->val);
        phead = phead->next;
    }

    phead = head;
    while (!st.empty())
    {
        if (st.top() != phead->val)
        {
            return false;
        }
        st.pop();
        phead = phead->next;
    }
    return true;
}

（二）vector+双指针

  • 思路和第一种解法的相差不大：
  • 可以先将链表节点中的val值装入vector中，然后再从vector中利用双指针对两个指针所指向的节点的val值进行比较即可。
  • 代码如下：
bool isPalindrome(ListNode* head) 
{
    if (head == nullptr || head->next == nullptr)
    {
        return true;
    }

    vector<int> res;
    ListNode* phead = head;

    while (phead != nullptr)
    {
        res.push_back(phead->val);
        phead = phead->next;
    }

    for (int i = 0, j = res.size() - 1; i < j; i++, j--)
    {
        if (res[i] != res[j])
        {
            return false;
        }
    }
    return true;
}

（三）快慢指针+反转链表

  • 思路：
  • 我们需要先找到前半部分节点的尾节点；
  • 然后将后半部分节点反转；
  • 然后比较反转链表与没有反转链表的节点值；
  • 如果对应节点值有不相同的就说明不是回文链表；
  • 否则就是回文链表。
  • 代码如下：
//对链表进行反转
ListNode* reverse(ListNode* head)
{
    if (head == nullptr || head->next == nullptr)
    {
        return head;
    }

    ListNode* pre = nullptr;
    ListNode* cur = head;
    ListNode* next = nullptr;

    while (cur != nullptr)
    {
        next = cur->next;
        cur->next = pre;
        pre = cur;
        cur = next;
    }

    return pre;
}

//找到链表的中间节点
ListNode* Findmidnode(ListNode* head)
{
    if (head == nullptr || head->next == nullptr)
    {
        return head;
    }

    ListNode* fast = head;
    ListNode* slow = head;

    while (fast->next != nullptr && fast->next->next != nullptr)
    {
        fast = fast->next->next;
        slow = slow->next;
    }
    return slow;
}

bool isPalindrome(ListNode* head)
{
    if (head == nullptr || head->next == nullptr)
    {
        return true;
    }

    //找到前半部分链表的尾节点
    ListNode* end = Findmidnode(head);

    //反转后半部分链表
    ListNode* first = reverse(end->next);

    //判断是否是回文链表
    while (first != nullptr)
    {
        if (first->val != head->val)
        {
            return false;
        }
        first = first->next;
        head = head->next;
    }
    return true;
}

旺财加油！✨

「已注销」
关注
专栏目录
链表基础知识与题目整理(Python)
A496608119的博客
01-12 1324
1.链表简介 1.1 链表定义 链表(Linked List)： 一种线性表数据结构。它使用一组任意的存储单元（可以是连续的，也可以是不连续的），来存储一组具有相同类型的数据。 比如单链表： 如上图所示，链表通过将一组任意的存储单元串联在一起。 链表节点： 每个数据元素占用若干存储单元的组合称为一个链接点。 链表节点的存储内容: 数据元素的值+后继指针（后继指针是指出这个数据元素在逻辑关系上的直接后继元素所在链节点的地址）。 数据之间的逻辑关系：逻辑关系是通过后继指针来简介反映的。逻辑上相邻的数据数素在物
链表练习整理
m0_62550074的博客
06-17 618
本题要求求出单链表值最大的结点并返回。要求实现两个函数。 函数接口定义： 其中arr存放创建单链表所需的数据（均为正整数），n 的值不超过1000； head 为不带附加头结点的单链表的头指针。裁判测试程序样例： 输入样例： 输出样例： 查找学生链表 根据键盘输入数据创建链表 在链表中查询 本题要求将键盘输入的学生信息创建成单向链表，并在学生信息链表中查找学生信息。学生信息链表结点定义如下： 需要创建的函数包括： 创建学生信息链表函数：CreateList 查找学生信息链表函数：Find 函数接口定义：
【链表】相关类型题目整理[二]
csdn_edition的博客
05-23 543
文章目录一、力扣21.合并两个有序链表（一）直接修改节点中的val[一般情况下不可取]（二）迭代法（三）递归 一、力扣21.合并两个有序链表 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 输入输出示例： 提示： （一）直接修改节点中的val[一般情况下不可取] 第一步，先将两个链表合并起来； 第二步，遍历一遍合并以后的链表，将他们的val值装入一个vector中； 第三步，对vector从小到大排序； 第四步，将排好序的vector中的元素按
leetcode链表类型题目整理（一）
weixin_45459911的博客
08-24 295
文章目录题目1：删除中间节点 用于记录在leetcode上处理链表问题时遇到的困难或是very nice的处理技巧。 （持续补充中…） 题目1：删除中间节点 注意事项： 注意题目链表定义 无法访问到head，只能访问到所给的节点（以及后续节点） 不知道pre，可以将next的值赋给当前，然后将当前当做pre，删掉next 正确答案： ...
【链表】相关类型题目整理[一]
csdn_edition的博客
05-21 409
文章目录一、力扣206.反转链表（一）不带头节点的单链表原地反转（二）利用栈的先进后出特点（三）递归（空间复杂度O(n)） 一、力扣206.反转链表 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。 示例1： 示例2： 示例3： （一）不带头节点的单链表原地反转 单链表结构： struct ListNode { int val; struct ListNode* next; }ListNode; 思路如下： 代码如下： struct L
链表的各种题目整理
bxw1992的博客
08-24 402
链表的各种题目整理(C语言实现)(Simple and Brief) 最后更新于Date:2012-11-04 这里处理的全部是单链表: typedef struct node { char *data; struct node *next; } node_t; 我们约定一个打印链表的函数: void list_display(node_t *head) {
线性表(链表)题目算法题目整理(附代码)
Sizaif's 小屋
08-24 1877
说明： 部分题目为王道题目整理，(ps.王道上思路没问题，在实现代码上略有些问题) 因个人代码风格与王道略有不同，部分细节代码也不尽相同 个人整理by sizaif 链表题目算法整理链表：1) **输入一组整型元素序列，使用尾插法(头插法)建立一个带有头结点(不带头结点)的单链表**。**2) 在该单链表的第i个元素前插入一个整数。(从0开始)**3) 删除该单链表中的第i个元素，其值通过参数将其返回(从0开始)。4) 建立两个按值递增有序的带头结点的单链表，将他们合并成一个按值递减有序.
链表题目整理(C语言实现)
jiao1197018093的专栏
04-28 1067
%title 链表的各种题目整理(C语言实现)(Simple and Brief) 最后更新于Date:2012-11-04 这里处理的全部是单链表: typedef struct node { char *data; struct node *next; } node_t; 我们约定一个打印链表的函数: void list_display(node
LeetCode热题100中关于链表的题目整理（待更）
代码之美
01-24 204
反转链表（simple难度） https://leetcode-cn.com/problems/reverse-linked-list/ 与本题相同的题目： 剑指offer24.反转链表 本题思路及代码实现： 作者：wang_ni_ma 链接：https://leetcode-cn.com/problems/reverse-linked-list/solution/dong-hua-yan-shi-206- 来源：力扣（LeetCode） class Solution
题目整理(链表).pdf
08-26
链表题目整理 链表是一个基本的数据结构，广泛应用于计算机科学和软件开发中。以下是链表相关的知识点总结： 1. 链表的基本概念：链表是一种动态存储结构，通过指针将各个结点连接起来，结点中包含数据域和指针域...
题目整理(二叉树).pdf
08-26
在本文件中，整理了与二叉树相关的多个考点，涵盖了建立二叉树、遍历二叉树、二叉树的深度和高度计算、二叉树的平衡判断、二叉树的修改操作等多个方面的算法知识。以下是整理的知识点： 1. 建立二叉树的二叉链表： ...
考虑励磁控制系统的水热两区互联电力系统网络自动生成控制simulink.rar
10-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
Python 实现BO-CNN-BiLSTM贝叶斯优化卷积双向长短期记忆网络数据多变量时间序列预测（包含详细的完整的程序和数据）
10-09
内容概要：本文详细介绍了如何使用 Python 和深度学习方法（包括卷积神经网络 CNN 与双向长短期记忆网络 BiLSTM 结合的 BO-CNN-BiLSTM）进行多变量时间序列的数据预测。内容涵盖了从数据准备到超参数优化的全过程，并提供了完整的代码实现和实例展示。 适用人群：机器学习初学者，尤其适合对时间序列预测感兴趣的深度学习爱好者、研究者、工程技术人员。 使用场景及目标：适用于需要对时间序列数据如股票价格、环境数据、医疗健康监控等领域做精准预测的情况。本教程可以帮助理解深度学习在网络模型优化方面的运用。 其它：文中还讨论了项目的注意事项，并指出了可能的方向性改进路径，比如增加模型解释能力、实际应用等
用于kpca降维，对于故障特征诊断具有重要的作用不能运行.rar
10-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
Python 实现 INFO-ELM（向量加权算法优化极限学习机）进行多输入单输出回归预测（包含详细的完整的程序和数据）
10-09
内容概要：本文详细介绍了如何利用PYTHON实现INFO-ELM（一种加权优化极限学习机）来进行多输入单输出（MISO）回归预测的方法。其中包括数据生成、算法建模、权重迭代更新以及最终的效果评估等一系列过程，并附有可视化的结果比较。 适用人群：适合熟悉或正在学习机器学习基本理论，特别是有兴趣深入理解和应用ELM和加权回归算法的研究人员和技术人员。 使用场景及目标：适用于解决多个输入变量对应一个连续数值输出的实际预测问题，通过优化模型提升预测准确性和稳定性。 其他说明：文中还提供了进一步研究和改进的方向，如扩展隐含节点数量、改善权重调节方法及采用平行计算等方式提高预测质量。
005-基于51单片机的酒精测试设计
最新发布
10-09
请结合博客看 https://blog.csdn.net/weixin_41011452/article/details/140587967?spm=1001.2014.3001.5502
频率约束下电力系统干扰的鲁棒性 matlab代码.rar
10-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
利用SIMULINK生成简单的QPSK调制器.rar
10-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
程序员面试：二元查找树转排序双向链表解析
在提供的部分题目中，提到了一个常见的面试问题——如何将二元查找树（Binary Search Tree, BST）转换成排序的双向链表（Sorted Doubly Linked List），而不创建新的节点，只是调整节点间的指针。这是一个典型的算法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值