代码随想录（二）：链表

已于 2023-04-06 10:16:36 修改
阅读量132 收藏
点赞数
分类专栏： 代码随想录题解 文章标签： leetcode 算法 数据结构 链表
于 2023-03-20 23:08:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45029883/article/details/129678679
版权

文章目录

203.移除链表元素

力扣题目链接

题意：删除链表中等于给定值 val 的所有节点。

示例 1： 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5]

示例 2： 输入：head = [], val = 1 输出：[]

示例 3： 输入：head = [7,7,7,7], val = 7 输出：[]

代码如下：

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummy = new ListNode(-1);
        dummy->next = head;
        auto cur = dummy;
        while (cur->next) {
            if (cur->next->val == val) cur->next = cur->next->next;
            else cur = cur->next;
        }
        return dummy->next;
    }
};

707.设计链表

力扣题目链接

题意：

在链表类中实现这些功能：

  • get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
  • addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
  • addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
  • addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
  • deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。
    在这里插入图片描述
    代码如下：
class MyLinkedList {
public:
    struct Node {
        int val;
        Node* next;
        Node(int _val): val(_val), next(NULL) {}
    }*head;
    MyLinkedList() {
        head = NULL;
    }
    
    int get(int index) {
        if (index < 0) return -1;
        auto p = head;
        for (int i = 0; i < index && p; i++) p = p->next;
        if (!p) return -1;
        return p->val;
    }
    
    void addAtHead(int val) {
        auto cur = new Node(val);
        cur->next = head;
        head = cur;
    }
    
    void addAtTail(int val) {
        if (!head) head = new Node(val);
        else {
            auto p = head;
            while (p->next) p = p->next;
            p->next = new Node(val);
        }
    }
    
    void addAtIndex(int index, int val) {
        if (index <= 0) addAtHead(val);
        else {
            int len = 0;
            for (auto p = head; p; p = p->next) len++;
            if (index == len) addAtTail(val);
            else if (index < len) {
                auto p = head;
                for (int i = 0; i < index - 1; i++) p = p->next;
                auto cur = new Node(val);
                cur->next = p->next;
                p->next = cur;
            }
        }
    }
    
    void deleteAtIndex(int index) {
        int len = 0;
        for (auto p = head; p; p = p->next) len++;
        if (index >= 0 && index < len) {
            if (!index) head = head->next;
            else {
                auto p = head;
                for (int i = 0; i < index - 1; i++) p = p->next;
                p->next = p->next->next;
            }
        }
    }
};

206.反转链表

力扣题目链接

题意：反转一个单链表。

示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL

算法1
(链表操作，迭代) O(n)
翻转即将所有节点的next指针指向前驱节点。
由于是单链表，我们在迭代时不能直接找到前驱节点，所以我们需要一个额外的指针保存前驱节点。同时在改变当前节点的next指针前，不要忘记保存它的后继节点。

空间复杂度分析：遍历时只有3个额外变量，所以额外的空间复杂度是 O(1)。
时间复杂度分析：只遍历一次链表，时间复杂度是 O(n)。

代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode *prev = nullptr;
        ListNode *cur = head;
        while (cur)
        {
            ListNode *next = cur->next;
            cur->next = prev;
            prev = cur, cur = next;
        }
        return prev;
    }
};

算法2
(链表操作，递归) O(n)
首先我们先考虑 reverseList 函数能做什么，它可以翻转一个链表，并返回新链表的头节点，也就是原链表的尾节点。
所以我们可以先递归处理 reverseList(head->next)，这样我们可以将以head->next为头节点的链表翻转，并得到原链表的尾节点tail，此时head->next是新链表的尾节点，我们令它的next指针指向head，并将head->next指向空即可将整个链表翻转，且新链表的头节点是tail。

空间复杂度分析：总共递归 n 层，系统栈的空间复杂度是 O(n)，所以总共需要额外 O(n) 的空间。
时间复杂度分析：链表中每个节点只被遍历一次，所以时间复杂度是 O(n)。

C++ 代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (!head || !head->next) return head;
        ListNode *tail = reverseList(head->next);
        head->next->next = head;
        head->next = nullptr;
        return tail;
    }
};

24. 两两交换链表中的节点

力扣题目链接

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

Alt

方法一：通过改变结点的指针，达到两两交换链表中的结点的目的
请添加图片描述
建立虚拟头结点，代码中的p、a、b的初始化位置如上图所示。

代码如下：

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        auto dummy = new ListNode(-1);
        dummy->next = head;
        for (auto p = dummy; p->next && p->next->next;) {
            auto a = p->next, b = a->next;
            p->next = b;
            a->next = b->next;
            b->next = a;
            p = a;
        }
        return dummy->next;
    }
};

方法二：通过两两交换链表中的节点的值，达到两两交换链表中的节点的目的

代码如下：

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if (!head || !head->next) return head;
        ListNode* pre = head;
        ListNode* cur = head->next;
        while (1) {
            int temp = pre->val;
            pre->val = cur->val;
            cur->val = temp;
            if(cur->next && cur->next->next) pre = cur->next, cur = pre->next;
            else break;
        }
        return head;
    }
};

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

力扣题目链接
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
示例 1：
输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5]
示例 2：
输入：head = [1], n = 1 输出：[]
示例 3：
输入：head = [1,2], n = 1 输出：[1]

代码如下：

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        auto dummy = new ListNode(-1);
        dummy->next = head;
        int len = 0;
        for (auto p = head; p; p = p->next) len++;
        int x = len - n;
        auto cur = dummy;
        for (int i = 0; i < x; i++) {
            cur = cur->next;
        }
        cur->next = cur->next->next;
        
        return dummy->next;
    }
};

160. 链表相交

力扣题目链接
题目描述
给定两个链表，请找它们的交汇点。

注意：
如果两个链表不相交，则返回null；
在函数结束时，两个链表必须保持原来的结构；
链表中不存在环；
你的代码需要的时间复杂度是O(n)，额外的空间复杂度是O(1)；
样例
给定如下两个链表：

A:          a1 → a2
                    ↘
                      c1 → c2 → c3
                    ↗            
B:     b1 → b2 → b3

则交汇点是 c1。

算法
(链表，指针扫描) O(n)
这题的思路很巧妙，我们先给出做法，再介绍原理。

算法步骤：

  1. 用两个指针分别从两个链表头部开始扫描，每次分别走一步；
  2. 如果指针走到null，则从另一个链表头部开始走；
  3. 当两个指针相同时，
  • 如果指针不是null，则指针位置就是相遇点；
  • 如果指针是 null，则两个链表不相交；

此题我们画图讲解，一目了然：

  1. 两个链表不相交：
    在这里插入图片描述
    a,b 分别代表两个链表的长度，则两个指针分别走 a+b 步后都变成 null。

  2. 两个链表相交：
    在这里插入图片描述
    则两个指针分别走 a+b+c 步后在两链表交汇处相遇。

时间复杂度分析：每个指针走的长度不大于两个链表的总长度，所以时间复杂度是 O(n)。

C++ 代码

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode *p = headA, *q = headB;
        while (p != q)
        {
            if (p) p = p->next;
            else p = headB;
            if (q) q = q->next;
            else q = headA;
        }
        return p;
    }
};

142. 环形链表 II

力扣题目链接
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改链表。
请添加图片描述
解题思路：
(链表，快慢指针扫描) O(n)
本题的做法比较巧妙。
用两个指针 fast,slow同时从起点开始走，slow每次走一步，fast每次走两步。
如果过程中fast走到null，则说明不存在环。否则当slow和fast相遇后，让fast返回起点，slow待在原地不动，然后两个指针每次分别走一步，当两个指针再次相遇时，相遇点就是环的入口。
请添加图片描述
证明：如上图所示，a是起点，b是环的入口，c是两个指针的第一次相遇点，ab之间的距离为 x，bc之间的距离是y。
则当slow走到b时，由于fast比slow多走一倍的路，所以fast已经从b开始在环上走了x步到d，可能多余1圈，距离b还差y步（这是因为第一次相遇点在b之后y步，我们让slow退回到b点，则fast会退2y步到d点，也就是距离b点还差y步）；所以fast从b点走x+y步即可回到b点，所以fast从c点开始走，走x步即可恰好走到b点，同时让slow从头开始走，走x步也恰好可以走到b点。所以第二次相遇点就是b点。

时间复杂度分析：slow总共走了2x+y步，fast总共走了2x+2y+x步，所以两个指针总共走了5x+3y步。由于当第一次slow走到b点时，fast最多追一圈即可追上slow，所以y小于环的长度，所以x+y小于等于链表总长度。所以总时间复杂度是O(n)。

代码如下：

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        if (!head || !head->next) return 0;
        ListNode *slow = head, *fast = head;

        while (fast) {
            slow = slow->next;
            fast = fast->next;
            if (fast) fast = fast->next;
            else return NULL;
            if (fast == slow) {
                slow = head;
                while (fast != slow) {
                    fast = fast->next;
                    slow = slow->next;
                }
                return fast;
            }
        } 
        return NULL;
    }
};
程序员小浩
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux ...
代码随想录 面试大厂必备八股文
07-03
《代码随想录》是众多程序员面试准备的重要参考资料，尤其对于目标是大厂的开发者来说，这本书中的“面试大厂必备八股文”更是不容忽视的内容。这里的“八股文”并非传统意义上的文学形式，而是指在编程面试中经常被...
代码随想录02：链表
DLNovice的博客
10-24 671
代码随想录02：链表
代码随想录：链表
m0_74345527的博客
06-29 964
代码随想录--链表篇
代码随想录刷题记录：链表篇
qq_53324833的博客
01-17 449
前言 本篇为代码随想录的第二篇，链表篇。 203. 移除链表元素 题目描述： 思路： LeetCode这个题还是有很多陷阱的，我之前写过类似的一遍就过了而这次栽了很多坑。 首先我们要知道要删除的值可能有很多个，其次要知道头结点也可能是我们要删除的节点，也有可能在头结点之后几个节点都是我们要删除的，最后要记得我们的最后一个节点也可能是我们要删除的。 综上，代码如下，注释很详尽了： /** * Definition for singly-linked list. * public class ListNo
代码随想录：04链表
qq_32565805的博客
09-13 61
【代码】04、链表。
代码随想录——重排链表
qq_39473176的博客
11-10 803
刷题总结
代码随想录：链表6-8
weixin_46531010的博客
03-25 552
1.思想：要删除倒数第n个节点，就让fast先走n步，然后slow和fast一起走，直到fast指向最后一个节点，此时slow指向的正好是待删除节点的前一个节点。2.注意点：fast.next!= null，不能少next，因为fast要指向最后一个节点时，slow指向待删除节点的前一个，fast如果指向null了，slow已经是要删除的节点了，多走了一步。1.思想：要找到两个链表何时相交，返回相交的节点。
代码随想录day4:链表总结
qq_45789731的博客
10-29 564
迭代法：发现的规律是，本质上一组同时改变新的节点。重复的是，原来head-》next也就是newhead变成了新的头结点。而且要每次返回交换顺序的头结点给上一组。一开始自己的思路只是两两交换，并没有说涉及到前一个节点。实际上两两交换涉及到了三个节点。使用虚拟头结点，这样一次性处理三个节点。且每次组里第一个节点其实数值没变。
代码随想录笔记_链表_206反转链表
Erik_Ying的博客
07-19 215
力扣链表206
代码随想录Day4: 链表Part2
weixin_72783626的博客
03-09 901
但是我忘记了题目要求的是不能修改原数组，所以这种解法不可取，而且更严重的问题就是我们这里说的两个链表相交代表的是相交的那个node和之后的node在内存地址中也要是一样的，所以我一开始想的太简单了，但是其实相同之后解法并不难，只不过我需要用到extra memory目前，就把list a里面所有的node存在set里面就可以了，然后遍历list b 的node，第一个发现和set中匹配的就是相交的节点，如果没有一样的node，就return none就可以了。卡哥和我的解法不一样！
代码随想录day6 链表：环形链表 （leetcode142）
m0_56045842的博客
11-04 75
思路：本题判断链表是否有环可以通过快慢指针，快指针每次移动两位，慢指针每次移动一位，若二者相遇则说明链表有环。此题是找出入口位置，无论快指针在相遇前转多少圈，二者相遇的位置是固定的，所以我们不妨假设n=1。（由于二者的速度关系，慢指针走过路程乘2等于快指针走过的路程）题目要求：已知链表头结点，要求返回链表开始入环的第一个结点。假设快指针在环内转n圈以后会和慢指针相遇，则有以下等式。本题代码实现较简单，注意解题思路。
代码随想录算法PDF.zip
05-29
《代码随想录》是一本深受程序员喜爱的算法学习书籍，其PDF版本为读者提供了方便的电子阅读体验。这本书主要针对准备参加编程面试或者想要提升自己算法能力的开发者，通过实例解析和实战演练，帮助读者深入理解算法...
代码随想录算法PDF.rar
08-06
《代码随想录》是一本深受程序员喜爱的算法学习书籍，尤其对于初学者来说，它提供了深入浅出的讲解和实战演练。这本书的核心是通过实际编程来帮助读者理解和掌握算法，提升编程技能，特别是C++语言的应用。在C++这个...
代码随想录-大厂八股文稀有资源好几百页
04-19
代码随想录-大厂八股文稀有资源好几百页 本资源是一个关于代码面试和算法的综合资源，涵盖了C++、Java、Go等多种编程语言，涉及到Linux操作系统和数据结构等多个领域。以下是从该资源中提取的知识点： 一、C++基础...
力扣220题详解：存在重复元素 III 的多种解法与复杂度分析
10年数据\经营分析经验，现任大厂数据分析负责人
08-21 661
本文详细解读了力扣第220题“存在重复元素 III”，通过使用滑动窗口 + 桶排序和滑动窗口 + 有序集合两种方法高效地解决了这一问题，并提供了详细的解释和模拟面试问答。希望读者通过本文的学习，能够在力扣刷题的过程中更加得心应手。
leetcode242:有效的字母异位词
最新发布
qq_55630615的博客
08-23 196
hashmap法,正常应该用数组实现即可。中每个字符出现的次数都相同，则称。，编写一个函数来判断。
一起学习LeetCode热题100道（48/100）
weixin_53224223的博客
08-20 522
7.注意：虽然代码中包含了回溯部分（即减少当前路径和的计数并从prefixSums中删除它），但在本问题中，由于树是无环的，并且我们不需要精确跟踪每条路径，因此这部分是多余的。输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22。输入：root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8。1.这是主函数，接收根节点和目标和作为参数，并返回满足条件的路径数量。
Leetcode 219. 存在重复元素 II⭐️
铁马冰河入梦来
08-20 392
哈希表解决存在重复元素二问题
全国计算机二级C语言上机题库：链表求和解题关键
本篇文档提供了全国计算机二级C语言上机考试中的一个具体题目集，主要关注的是填空题部分，涉及链表操作和函数设计。以下是关键知识点的详细解析： 1. 题目背景与要求： 这是一道关于单向链表操作的题目，要求考生...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员小浩

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值