hot100 -- 链表（中）

news2024/11/26 12:52:30

不要觉得力扣核心代码模式麻烦，它确实比不上ACM模式舒服，可以自己处理输入输出

只是你对 链表 和 return 的理解不到位

👂 ▶ 屿前世 (163.com)

👂 ▶ see you tomorrow (163.com)

目录

🎂两数相加

🚩删除链表倒数第 N 个节点

AC  双指针

AC  栈

AC  计算链表长度

🌼两两交换链表中的节点

AC  递归

AC  迭代

🌼K 个一组翻转链表

🎂两数相加

2. 两数相加 - 力扣（LeetCode）

1）l1, l2 长度可能不一样，假设短的后面全是 0，通过三目运算符得到 当前节点的值，比如

n1 = l1 ? l1->val : 0

2）sum = n1 + n2 + 进位，%10 当前位，/10 进位

3）注意给节点赋值方式

tail->next = new ListNode(...);

4）可能漏最后一次进位，while() 结束后还要来一次

时间 O(max(m, n))，空间 O(1)

/**
 * 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* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode *head = nullptr, *tail = nullptr;

        int temp = 0; // 进位
        while (l1 || l2) {
            int n1 = l1 ? l1->val : 0; // l1 的值
            int n2 = l2 ? l2->val : 0;
            int sum = n1 + n2 + temp;

            if (!head) // 第1次
                head = tail = new ListNode(sum % 10); // 注意赋值方式
            else {
                // tail 上一步已经初始化, 所以现在是 tail->next
                tail->next = new ListNode(sum % 10); // 先给下一赋值
                tail = tail->next; // 再移动
            }

            temp = sum / 10; // 进位
            
            // l1, l2 向后移动
            if (l1) l1 = l1->next;
            if (l2) l2 = l2->next;
        }
        // 最后一次进位
        if (temp) 
            tail->next = new ListNode(temp);

        return head; // 不返回 tail, 防止 nullptr
    }
};

🚩删除链表倒数第 N 个节点

19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）

注意：链表的题，如果出现 Node->next，那么这个 Node 一定不为 nullptr，否则会报错

1，双指针：一前一后，前面的先移动 n 个位置，然后开始同步移动

2，栈：思路类似双指针，最终都是遍历到待删除节点前一个（从栈顶开始出栈）

3，链表长度：思路类似前面，借助哑节点，避免对删除头节点的处理，遍历两次即可

AC  双指针

时间 O(L)，空间 O(1)，L 链表长度

自己写的

/**
 * 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* removeNthFromEnd(ListNode* head, int n) {
        ListNode *fast = head, *slow = head;
        // 前后指针 -- 找到倒数第 n 个节点, 即 slow
        while (n--)
            fast = fast->next;

        // 删除头节点
        if (!fast) {
            ListNode *temp = head;
            head = temp->next;
            delete temp;
            return head;
        }

        while (fast->next)
            slow = slow->next, fast = fast->next;

        // 删除 slow 下一节点
        ListNode *bad = slow->next; // 要删除的节点
        slow->next = slow->next->next;

        bad->next = nullptr;
        delete bad;

        // 上面处理了头节点被删除的情况，所以这里可以 return head
        return head; 
    }
};

官解重写

删除倒数第 n 个节点，通过指针的 next 来操作，最后的 delete 只是为了手动释放堆区数据（自己new的自己delete）

bad 的作用是，防止删的是第一个元素，因为最终会遍历到删除节点的前一个

如果不用 bad，就像前面的代码一样，特殊处理删除节点是头节点的情况

/**
 * 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* removeNthFromEnd(ListNode* head, int n) {
        // 初始化 head 上一位置,  bad->next = head
        ListNode *bad = new ListNode(0, head); 
        ListNode *fast = head, *slow = bad; // slow 初始化为 bad

        while (n--)
            fast = fast->next;

        while (fast) {
            fast = fast->next;
            slow = slow->next;
        }
        // 此时 slow 位于删除节点 上一位置
        slow->next = slow->next->next; // 更新连接
        ListNode *ans = bad->next; // 新的头节点
        delete bad;
        
        return ans; // 返回新的头节点
    }
};

AC  栈

/**
 * 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* removeNthFromEnd(ListNode* head, int n) {
        stack<ListNode *> s;
        // temp 的作用是，防止删的是第一个元素，因为最终会遍历到删除节点的前一个
        ListNode *temp = new ListNode(0, head);
        ListNode *cur = temp;
        // 链表节点全部入栈
        while (cur) {
            s.push(cur); // push_back 是 vector
            cur = cur->next;
        }
        // 弹出 n 个元素后，栈顶就是待删除节点前一个
        while (n--) 
            s.pop();
        
        ListNode *prev = s.top(); 
        prev->next = prev->next->next; // 先重新连接

        ListNode *ans = temp->next; // 再赋值新的头节点

        delete temp;

        return ans;
    }
};

AC  计算链表长度

同样，类似上面两种，通过头节点前的，哑节点，避免对删除头节点这种情况的处理

/**
 * 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* removeNthFromEnd(ListNode* head, int n) {
        ListNode *temp = new ListNode(0, head); // 哑节点，避免对头节点删除的处理
        ListNode *cur = temp;
        int len = 0;
        // 链表长度
        while (cur->next) { // 长度容易错
            len++;
            cur = cur->next;
        }
        cur = temp;
        int count = len - n;
        // 哑节点移动 len - n + 1，即待删除节点
        // 所以，移动 len - n，刚好待删除前一个
        while (count--) 
            cur = cur->next;
        cur->next = cur->next->next;
        ListNode *ans = temp->next; // 新的头节点
        delete temp;

        return ans;
    }
};

🌼两两交换链表中的节点

24. 两两交换链表中的节点 - 力扣（LeetCode）

AC  递归

head之前的不用处理，举个例子，比如

转换后 head = swapPairs(temp->next)，把两两视作一个整体，那么两两中的后一个，指向哪里，取决于后面递归的结果，所以只需考虑当前层

时间 O(n)，空间 O(n)（递归栈深度 n）

/**
 * 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:
    // head 表示递归时，当前两两交换节点的前一个
    ListNode* swapPairs(ListNode* head) {
        // 递归出口
        if (head == nullptr || head->next == nullptr)
            return head; // 只剩0个 或 1个节点
            
        // 只看当前层：交换两个节点
        ListNode *temp = head->next; 
        head->next = swapPairs(temp->next); // 递归交换剩余节点
        temp->next = head;
        return temp; // 返回新的头节点
    }
};

AC  迭代

类似冒泡排序，直接交换，但是需要借助哑节点 temp，比如

temp->Node1->Node2

👇

temp->Node2->Node1

时间 O(n)，空间 O(1)

/**
 * 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* swapPairs(ListNode* head) {
        ListNode *temp = new ListNode(0, head); // 初始 temp->next == head
        ListNode *tempHead = temp; // 头节点前一个
        // 递归中的 head 是当前节点
        // 迭代中的 head 只表示原链表头节点
        // 所以 while 中不能用 head, 应该用 temp
        while (temp->next != nullptr && temp->next->next != nullptr) {
            ListNode *Node1 = temp->next;
            ListNode *Node2 = temp->next->next;
            // temp->Node1->Node2 ----> temp->Node2->Node1
            temp->next = Node2;
            Node1->next = Node2->next;
            Node2->next = Node1;
            // 新的哑节点
            temp = Node1;
        }
        ListNode *ans = tempHead->next; // 新链表头节点
        // delete tempHead; // 删除哑节点
        return ans; // 新的头节点
    }
};

🌼K 个一组翻转链表

25. K 个一组翻转链表 - 力扣（LeetCode）

模拟：迭代反转 + 新建连接

以下是新建连接的 3 个步骤

k = 3 也一样

和上/下一组新建连接时，要从外层开始，就是p0->next->next到p0->next最后才是p0

p0->next->next = cur; // 下一组头
p0->next = nex; // 上一组尾
p0 = p1; // 更新p0

时间 O(n)，空间 O(1)

/**
 * 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* reverseKGroup(ListNode* head, int k) {
        // 链表长度 len
        int len = 0;
        for (ListNode *cur = head; cur; cur = cur->next)
            len++;

        // temp->next  ==  head（temp/p0 -- 哑节点/哨兵节点）
        ListNode *temp = new ListNode(0, head);
        ListNode *p0 = temp; // p0 k个一组第一个节点的前一个

        ListNode *nex = nullptr, *cur = head;
        // k 个一组反转
        for (; len >= k; len -= k) {

            // 迭代 -- 反转（参考反转链表I）
            // 因为哨兵节点的存在，所以是 k 次而不是 k-1 次反转
            for (int i = 0; i < k; ++i) { // k 次反转
                ListNode *pre = cur->next; // pre 右移
                cur->next = nex; // 反转
                nex = cur; // nex 右移
                cur = pre; // cur 右移
            }

            // 当前组 与 上一组尾&&下一组头 连接
            ListNode *p1 = p0->next; // 新的p0
            p0->next->next = cur; // 下一组头
            p0->next = nex; // 上一组尾
            p0 = p1; // 更新p0
        }

        return temp->next; // 返回新链表的头节点
    }
};

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1600018.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

android不同版本（支持＞10）获取当前连接的wifi名称

android不同版本（支持＞10）获取当前连接的wifi名称

1、AndroidManifest.xml 配置权限 <uses-permission android:name"android.permission.ACCESS_COARSE_LOCATION" /> <uses-permission android:name"android.permission.CHANGE_NETWORK_STATE" /> <uses-permission android:name&q…
阅读更多...
Rust腐蚀服务器清档多教程

Rust腐蚀服务器清档多教程

Rust腐蚀服务器清档多教程 大家好我是艾西&#xff0c;一个做服务器租用的网络架构师。上期教了大家怎么搭建服务器以及安装插件等那么随着大家自己架设服或是玩耍的时间肯定会有小伙伴想要去新增开区数量或是把原本的服务器进行一些调整等&#xff0c;那么今天主要聊的就是怎…
阅读更多...
Cohere Command R+：企业级可扩展大模型

Cohere Command R+：企业级可扩展大模型

Command R 是一种最先进的 RAG 优化模型&#xff0c;旨在处理企业级工作负载&#xff0c;并首先在 Microsoft Azure 上提供 今天&#xff0c;我们推出了 Command R&#xff0c;这是我们最强大、可扩展的大型语言模型 &#xff08;LLM&#xff09;&#xff0c;专为在实际企业用…
阅读更多...
tailwindcss在manoca在线编辑智能感知

tailwindcss在manoca在线编辑智能感知

推荐一下monaco-tailwindcss库&#xff0c;它实现在monaco-editor网页在线编辑器中对tailwindcss的智能感知提示&#xff0c;在利用tailwindcss实现html效果布局。非常的方便。 生成CSS
阅读更多...
Maven POM元素解析(二)

Maven POM元素解析(二)

一、parent <parent>元素包含定位此项目将从中继承的父项目所需的信息。注意&#xff1a;此元素的子元素不是插值的&#xff0c;必须作为文字值给定。 ElementTypeDescriptiongroupIdString要从中继承的父项目的组id。artifactIdString要从中继承的父项目的项目id。ver…
阅读更多...
python零基础入门笔记【源源老师】

python零基础入门笔记【源源老师】

1. print() 输出 &#xff08;1&#xff09;认识英文单词 print: 输出&#xff08;2&#xff09;print() 的作用 print()&#xff1a;用于在控制台上输出你想要的内容。 &#xff08;3&#xff09;代码演示 举例1&#xff1a; 【注意&#xff1a;】用双引号包裹的&#xff0…
阅读更多...
java创建线程池的方法

java创建线程池的方法

简介 线程池是一种用于管理和重用线程的机制&#xff0c;它可以有效地管理线程的创建和销毁&#xff0c;减少线程创建和销毁的开销&#xff0c;并且能够控制并发线程数量&#xff0c;避免资源耗尽和系统过载。Java 提供了java.util.concurrent 包来支持线程池的实现。 1.Threa…
阅读更多...
java（网络编程）

java（网络编程）

什么是网络编程? 在网络通信协议下&#xff0c;不同计算机上运行的程序&#xff0c;进行的数据传输。 应用场景&#xff1a;即时通信、网游对战、金融证券、国际贸易、邮件、等等 不管是什么场景&#xff0c;都是计算机跟计算机之间通过网络进行数据传输 Java中可以使用ja…
阅读更多...
Qt | 事件第二节

Qt | 事件第二节

Qt | 事件第一节书接上回 四、事件的接受和忽略 1、事件可以被接受或忽略，被接受的事件不会再传递给其他对象，被忽略的事件会被传递给其他对象处理，或者该事件被丢弃(即没有对象处理该事件) 2、使用 QEvent::accept()函数表示接受一个事件，使用 QEvent::ignore()函数表示…
阅读更多...
fork()的一道面试题

fork()的一道面试题

前言&#xff1a;题源 #include <stdio.h> #include <sys/types.h> #include <unistd.h> #include <sys/wait.h> int main(void) {int i;for(i0; i<2; i){fork();printf("-");}wait(NULL);wait(NULL);return 0; }知道一点fork()这个系统…
阅读更多...
移动硬盘盒支持PD充电：优势解析与实际应用探讨

移动硬盘盒支持PD充电：优势解析与实际应用探讨

随着科技的飞速发展&#xff0c;数据存储和传输的需求日益增长&#xff0c;移动硬盘盒作为便携式存储设备的重要载体&#xff0c;其功能和性能也在不断提升。近年来&#xff0c;越来越多的移动硬盘盒开始支持PD&#xff08;Power Delivery&#xff09;充电技术&#xff0c;这一…
阅读更多...
【云计算】云数据中心网络（四）：IPv6 网关

【云计算】云数据中心网络（四）：IPv6 网关

云数据中心网络&#xff08;四&#xff09;&#xff1a;IPv6 网关 1.什么是 IPv6 网关2.IPv6 网关设计思路3.IPv6 网关的主要应用场景3.1 IPv6 私网通信3.2 IPv6 互联网通信3.3 IPv6 互联网通信&#xff08;仅主动访问&#xff09; 1.什么是 IPv6 网关 2017 年&#xff0c;中国…
阅读更多...
WordPress 多站点切换域名完整指南：详细步骤和注意事项

WordPress 多站点切换域名完整指南：详细步骤和注意事项

因为公司的需要&#xff0c;需要对 WordPress 多站点进行域名切换, 一开始我也找了相关的方案和教程&#xff0c;但是很可惜&#xff0c;国内这一块网上的资料几乎为0&#xff0c;所以我把实现的过程写了一篇文章分享出来&#xff0c;为后来的人铺路。 开始之前&#xff0c;先…
阅读更多...
Linux三剑客之awk篇

Linux三剑客之awk篇

目录 1、awk 1.1、awk参数 1.2、awk变量 1.3、awk分割符 1.3.1、FS 1.3.2、OFS 1.3.3、RS 1.3.4、ORS 1.3.5、NF 1.3.6、NR 1.3.7、FNR 1.3.8、FILENAME 1.3.9、ARGC与ARGV 1.4、自定义变量 1.5、printf格式化输出 1、awk 作用&#xff1a;具有强大的文本格式化…
阅读更多...
软考 - 系统架构设计师 - 嵌入式真题

软考 - 系统架构设计师 - 嵌入式真题

问题 1&#xff1a; &#xff08;1&#xff09;.HTML 静态化&#xff1a;可以实现对系统经常访问的页面进行静态化以提高系统访问的效率&#xff0c;但系统页面通常需要数据库中的用户信息和用户选择来动态显示&#xff0c;因此不适合采用。 HTML 静态化&#xff1a; 将动态生成…
阅读更多...
20240416如何使用git对本地文件进行上传

20240416如何使用git对本地文件进行上传

0 写在前面 年前收到硕导消息要搭建一下github仓库&#xff0c;一直没倒出时间整理&#xff0c;如今终于有时间搭建&#xff0c;顺带解决出现的问题。 1 安装git 安装git这步比较简单&#xff0c;随手一搜就有很多教程。git的作用主要是一种媒介&#xff0c;连接本地主机与G…
阅读更多...
CC工具箱使用指南：【三调三大类面积汇总表(一首歌听到卡带)】

CC工具箱使用指南：【三调三大类面积汇总表(一首歌听到卡带)】

一、简介 群友定制工具。 CC工具箱已经做了一个三大类面积汇总表&#xff0c;奈何大家的模板好像还是都有点不太一样。 群友提供的模板如下&#xff1a; 可以看到&#xff0c;这里的土地权属信息很多&#xff0c;有乡镇、村民委员会、村民小组&#xff0c;还有用地权属信息【…
阅读更多...
Linux 指令之文件

Linux 指令之文件

1.开发背景 记录 linux 下对文件操作的指令 2.开发需求 记录常用的文件操作指令 3.开发环境 linux 操作系统&#xff0c;如果不支持需要查看是否存在对应的可执行文件 4.实现步骤 4.1 查找字符串 查找指定目录下包含指定的字符串 grep -rn "Timer frequency" .…
阅读更多...
React间接实现一个动态组件逻辑

React间接实现一个动态组件逻辑

在开发一个浏览器插件的时候&#xff0c;用的plasmo框架和react支持的&#xff0c;里面使用react开发一个菜单功能&#xff0c;但是又不想使用react-router&#xff0c;所以就想着能不能使用一个很简单的方式做一个替代方案&#xff1f;那肯定是可以。 我在引入一个组件后&…
阅读更多...
OneTab：一键收纳浏览器标签页，告别繁杂浏览

OneTab：一键收纳浏览器标签页，告别繁杂浏览

名人说&#xff1a;东边日出西边雨&#xff0c;道是无晴却有晴。——刘禹锡 创作者&#xff1a;Code_流苏(CSDN)&#xff08;一个喜欢古诗词和编程的Coder&#x1f60a;&#xff09; 目录 一、OneTab二、主要功能三、安装方法1、Chrome应用商店&#xff08;需科学&#xff09;2…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023