LeetCode hot100---链表专题(C++语言)

news2024/10/5 5:24:18

1、相交链表

（1）题目描述以及输入输出

(1)题目描述:
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交点，返回 null 。
(2)输入输出描述：
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'

关键思路：
定义两个节点同时从两个链表遍历，遍历到头后，从另一个链表开始遍历，到相遇处就是交点

（2）代码块

/**
 * 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 *A = headA;
        ListNode *B = headB;
        while(A != B)
        {
            A = (A == NULL)?headB:A->next;
            B = (B == NULL)?headA:B->next;
        }
        return A;
    }
};

2、翻转链表

（1）题目描述以及输入输出

(1)题目描述:
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
(2)输入输出描述：
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

关键思路：
从链表头开始遍历，cur保留当前节点，每次遍历更新pre  cur_next位置

（2）代码块

/**
 * 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* reverseList(ListNode* head) 
    {
        ListNode* cur = head;
        ListNode* pre = nullptr;
        ListNode* cur_next = nullptr;
        while(cur != nullptr)
        {
            cur_next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = cur_next;
        }
        return pre;

    }
};

3、回文链表

（1）题目描述以及输入输出

(1)题目描述:
给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。
(2)输入输出描述：
输入：head = [1,2,2,1]
输出：true

关键思路：
先遍历链表，用数组承接链表元素，接着使用双指针判断数组首尾元素是否一直相等。

（2）代码块

/**
 * 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:
    bool isPalindrome(ListNode* head) 
    {
        vector<int> record;
        ListNode* phead = head;
        int left,right;
        if(head == nullptr)return false;

        while(phead)
        {
            record.push_back(phead->val);
            phead = phead->next;
        }

        left = 0;
        right = record.size()-1;
        while(left<=right)
        {
            if(record[left] != record[right])
                return false;
            left++;
            right--;
        }
        return true;
    }
};

4、环形链表

（1）题目描述以及输入输出

(1)题目描述:
给你一个链表的头节点 head ，判断链表中是否有环。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。
如果链表中存在环 ，则返回 true 。 否则，返回 false 。

(2)输入输出描述：
输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

关键思路：
使用快慢双指针遍历链表，快指针每次走两步，慢指针走1步。
若存在环，总会相遇。

（2）代码块

/**
 * 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) {
        ListNode* fast = head;
        ListNode* slow = head;

        while(fast && fast->next)
        {
            
            slow = slow->next;
            fast = fast->next->next;
            if(slow == fast)return true;
        }
        return false;
    }
};

5、环形链表||

（1）题目描述以及输入输出

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

(2)输入输出描述：
输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

关键思路：
使用快慢双指针遍历链表，快指针每次走两步，慢指针走1步。若存在环，总会相遇。
相遇后要找到环的入口节点。x+n*(y+z) = 2*(x+y),假如在y点相遇。相遇后快指针移到开头，快慢指针同时向后遍历，相遇处即交点。

（2）代码块

/**
 * 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) 
    {
        ListNode* fast = head;
        ListNode* slow = head;

        while(1)
        {
            if(fast && fast->next)
            {
                fast = fast->next->next;
                slow = slow->next;
                if(fast == slow)
                    break;
            }
            else
                return NULL;
            
        }

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

6、合并两个有序链表

（1）题目描述以及输入输出

(1)题目描述:
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 

(2)输入输出描述：
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

关键思路：
定义数组保存两个链表中各项的值，对于每个值开辟节点保存到链表中

（2）代码块

/**
 * 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* p = list1;
        if(list1 == NULL && list2 == NULL)return NULL;

        vector<int> record;
        while(p)
        {
            record.push_back(p->val);
            p = p->next;
        }
        p = list2;
        while(p)
        {
            record.push_back(p->val);
            p = p->next;
        }

        sort(record.begin(),record.end());
        ListNode* head = new ListNode(record[0]);
        p = head;
        for(int i = 1;i<record.size();i++)
        {
            ListNode* tmp = new ListNode(record[i]);
            p->next = tmp;
            p = p->next;

        }
        return head;
            
    }
};

7、两数相加

（1）题目描述以及输入输出

(1)题目描述:
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位数字。请你将两个数相加，并以相同形式返回一个表示和的链表。你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

(2)输入输出描述：
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

关键思路：
遍历两个链表，将其值相加得到record，创建新节点保存各项值的个位，然后record保存值的十位，然后平移cur节点，进入下一轮循环。

（2）代码块

/**
 * 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* dummy = new ListNode(0);
        ListNode* cur = dummy;
        int record = 0;
        while(l1||l2||record)
        {
            if(l1)
            {
                record += l1->val;
                l1 = l1->next;
            }
            if(l2)
            {
                record += l2->val;
                l2 = l2->next;
            }
            
            cur->next = new ListNode(record%10);
            cur = cur->next;
            record /= 10;
        }
        return dummy->next;
    }
};

8、删除链表倒数第N个节点

（1）题目描述以及输入输出

(1)题目描述:
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

(2)输入输出描述：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

关键思路：
定义快慢指针，快指针先走N步，接着快慢指针同时向后遍历，快指针遍历到末尾时，慢指针指向的是待删除元素的前一节点。跳过节点即可，

（2）代码块

/**
 * 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* dummyhead = new ListNode();
        dummyhead->next = head;

        ListNode* fast = dummyhead;
        ListNode* slow = dummyhead;
        while(n--)
        {
            fast = fast->next;
        }
        while(fast->next != nullptr)
        {
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next;
        return dummyhead->next;

    }
};

9、两两交换链表中的节点

（1）题目描述以及输入输出

(1)题目描述:
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。

(2)输入输出描述：
输入：head = [1,2,3,4]
输出：[2,1,4,3]

关键思路：
交换两个节点要保留四个节点，chang1、change2、pre、nect_change；做完赋值后，开始构建链表。

（2）代码块

/**
 * 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* pre = new ListNode();  			// 两节点的前一节点  
        pre->next = head;

        ListNode* dummyhead = pre;
        ListNode* next_change1 = nullptr;			// 两节点的后一节点
        ListNode* change1 = nullptr;
        ListNode* change2 = nullptr;

        while((pre->next != nullptr) && (pre->next->next != nullptr))
        {
            change1 = pre->next;
            change2 = pre->next->next;
            next_change1 = pre->next->next->next;

            pre->next = change2;                    // 使得链表结构完整pre->2->1->3->4
            change2->next = change1;                
            change1->next = next_change1;           // 交换节点
            
            pre = change1;                          // 更新下两节点的前节点
        }
        return dummyhead->next;
    }
};

10、随机链表的复制

（1）题目描述以及输入输出

(1)题目描述:
深拷贝随机链表

关键思路：
使用map<Node*,Node*>进行链表拷贝，先遍历链表，一个cur对应一个拷贝出来的新节点。此时只是在哈希表中保存了所有节点。
接着再次遍历链表，进行哈希表节点的链接。

（2）代码块

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/

class Solution {
public:
    Node* copyRandomList(Node* head) 
    {
        unordered_map<Node*,Node*> record;
        Node* cur = head;
        for(cur = head;cur;cur = cur->next)
        {
            record[cur] = new Node(cur->val);		//先把当前节点拷贝下来
        }    

        for(cur = head;cur;cur = cur->next)
        {
            if(cur->next)record[cur]->next = record[cur->next];
            if(cur->random)record[cur]->random = record[cur->random];
        }
        return record[head];
    }
};

11、排序链表

（1）题目描述以及输入输出

(1)题目描述:
给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 

(2)输入输出描述
输入：head = [4,2,1,3]
输出：[1,2,3,4]

关键思路：
遍历链表，将链表各节点值保存至数组中，对数组排序，接着再遍历链表，修改链表中各节点值

（2）代码块

/**
 * 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* sortList(ListNode* head) 
    {
        vector<int> record;
        ListNode *phead = head;
        while(phead)
        {
            record.push_back(phead->val);
            phead = phead->next;
        }
        sort(record.begin(),record.end());

        phead = head;
        int k = 0;
        while(phead)
        {
            phead->val = record[k++];
            phead = phead->next;
        }
        return head;
    }
};

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

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

相关文章

KVM虚拟化技术介绍

KVM虚拟化技术介绍

文章目录 前言一、pandas是什么&#xff1f;二、使用步骤 1.引入库2.读入数据总结 前言 虚拟化技术是云计算的基础&#xff0c;什么是虚拟化&#xff1f;虚拟化技术的本质是什么&#xff1f;主流的虚拟化技术有哪些&#xff1f;本章将为您揭晓 一.虚拟化概述 虚拟化是一种将计…
阅读更多...
【有啥问啥】领域自适应（Domain Adaptation, DA）详解

【有啥问啥】领域自适应（Domain Adaptation, DA）详解

领域自适应&#xff08;Domain Adaptation, DA&#xff09;详解 引言 在机器学习和深度学习的广泛应用中&#xff0c;一个核心挑战在于模型往往在一个特定数据集&#xff08;源领域&#xff09;上训练后&#xff0c;难以直接应用于另一个不同但相关的数据集&#xff08;目标领…
阅读更多...
通信工程学习：什么是ICMP因特网控制报文协议

通信工程学习：什么是ICMP因特网控制报文协议

ICMP&#xff1a;因特网控制报文协议 ICMP&#xff08;Internet Control Message Protocol&#xff0c;因特网控制报文协议&#xff09;是TCP/IP协议簇中的一个重要子协议&#xff0c;主要用于在IP主机和路由器之间传递控制消息。以下是关于ICMP协议的详细解释&#xff1a; 一…
阅读更多...
Pikachu-Unsafe FileUpload-客户端check

Pikachu-Unsafe FileUpload-客户端check

上传图片&#xff0c;点击查看页面的源码&#xff0c; 可以看到页面的文件名校验是放在前端的&#xff1b;而且也没有发起网络请求&#xff1b; 所以&#xff0c;可以通过直接修改前端代码&#xff0c;删除 checkFileExt(this.value) 这部分&#xff1b; 又或者先把文件名改成…
阅读更多...
九、2 USART串口外设

九、2 USART串口外设

1、STM32内部的USART外设的介绍 &#xff08;1&#xff09; STM32的USART的同步模式只是多了个时钟输出&#xff0c;只支持时钟输出&#xff0c;不支持时钟输入。该同步模式更多是为了兼容别的协议或者特殊用途而设计的&#xff0c;并不支持两个USART之间进行同步通信&#xf…
阅读更多...
剖解最小栈

剖解最小栈

最小栈 思路&#xff1a; 1. 首先实例化两个栈&#xff0c;分别是stack用于存放数据&#xff0c;minstack用于存放最小值 2. 将第一个元素压入两个栈中&#xff0c;判断此时若minStack栈中为空&#xff0c;则表示压入的为第一个数据 if ( minStack.empty () ) { minStack.pus…
阅读更多...
MySQL 查询优化器

MySQL 查询优化器

文章目录 控制查询计划optimizer_prune_leveloptimizer_search_depth 优化器参数优化器提示索引提示成本模型server_costcost_name engine_cost 控制查询计划 https://dev.mysql.com/doc/refman/8.4/en/controlling-query-plan-evaluation.html 在执行SQL前会根据优化器选择执…
阅读更多...
Leetcode 第 140 场双周赛题解

Leetcode 第 140 场双周赛题解

Leetcode 第 140 场双周赛题解 Leetcode 第 140 场双周赛题解题目1&#xff1a;3300. 替换为数位和以后的最小元素思路代码复杂度分析 题目2&#xff1a;3301. 高度互不相同的最大塔高和思路代码复杂度分析 题目3&#xff1a;3302. 字典序最小的合法序列思路代码复杂度分析 题目…
阅读更多...
入手一个小扒菜fqrr#com

入手一个小扒菜fqrr#com

fqrr#com 既带q又带r是很多人不喜的类型&#xff0c; 父亲 夫妻 番茄 分期 人人 日日 好无聊的米呀&#xff0c;竟然组合不出来意思 这个不是购买的&#xff0c;别人说他1150元购买的&#xff0c;算是半抵给我的吧 其实我也不喜欢&#xff0c;我4声母.com 已经够多了&am…
阅读更多...
【教程】文字转语音的3个方法，文字转语音使用攻略

【教程】文字转语音的3个方法，文字转语音使用攻略

文字转语音的需求还是蛮多的&#xff0c;很多用户在视频剪辑中会遇到。不想用本人的声音&#xff0c;那么视频中的旁白就只能通过文字转语音软件实现了。 想要将文字转为语音那还是蛮好解决的&#xff0c;如果你还在找方法&#xff0c;那么以下内容可以了解下。本文整理了三种简…
阅读更多...
2c 操作符详解

2c 操作符详解

1. 操作符分类&#xff1a; 算术操作符 移位操作符 位操作符 赋值操作符 单目操作符 关系操作符 逻辑操作符 条件操作符 逗号表达式 下标引用、函数调用和结构成员 2. 算术操作符 - * / % 1除了 % 操作符之外&#xff0c;其他的几个操作符可以作用于整数和浮点数。对于 / 操作…
阅读更多...
NVIDIA NVLink-C2C

NVIDIA NVLink-C2C

NVIDIA NVLink-C2C 文章目录 前言一、介绍1. 用于定制芯片集成的超快芯片互连技术2. 构建半定制芯片设计3. 使用 NVLink-C2C 技术的产品 二、NVLink-C2C 技术优势1. 高带宽2. 低延迟3. 低功率和高密度4. 行业标准协议 前言 将 NVLink 扩展至芯片级集成 一、介绍 1. 用于定制芯…
阅读更多...
Candance仿真二阶米勒补偿OTA

Candance仿真二阶米勒补偿OTA

1.OTA电路搭建目标——25Mhz GBW&#xff0c;65dB的增益 2.电路参照 3.candance电路搭建 实现步骤&#xff1a;应该是从下面这个公式开始推导 然后那个CL就是两边的那个CCa或CCb的大小 算出来就是gm75us
阅读更多...
MongoDB-aggregate流式计算：带条件的关联查询使用案例分析

MongoDB-aggregate流式计算：带条件的关联查询使用案例分析

在数据库的查询中&#xff0c;是一定会遇到表关联查询的。当两张大表关联时&#xff0c;时常会遇到性能和资源问题。这篇文章就是用一个例子来分享MongoDB带条件的关联查询发挥的作用。 假设工作环境中有两张MongoDB集合&#xff1a;SC_DATA&#xff08;学生基本信息集合&…
阅读更多...
基于微信小程序的旅游拼团系统

基于微信小程序的旅游拼团系统

作者&#xff1a;计算机学姐 开发技术&#xff1a;SpringBoot、SSM、Vue、MySQL、JSP、ElementUI、Python、小程序等&#xff0c;“文末源码”。 专栏推荐&#xff1a;前后端分离项目源码、SpringBoot项目源码、Vue项目源码、SSM项目源码、微信小程序源码 精品专栏&#xff1a;…
阅读更多...
Colorize: 0 variables Colorize is not activated for this file. VsCode

Colorize: 0 variables Colorize is not activated for this file. VsCode

问题情况 解决步骤 1.找到setting.json文件 2.输入以下代码&#xff0c;保存setting.json文件 "colorize.languages": ["css", "javascript", "sass", "less", "postcss", "stylus", "xml"…
阅读更多...
基于SpringBoot+Vue+MySQL的中医院问诊系统

基于SpringBoot+Vue+MySQL的中医院问诊系统

系统展示 用户前台界面 管理员后台界面 医生后台界面 系统背景 随着信息技术的迅猛发展和医疗服务需求的不断增加&#xff0c;传统的中医院问诊流程已经无法满足患者和医院的需求。纸质病历不仅占用大量存储空间&#xff0c;而且容易丢失和损坏&#xff0c;同时难以实现信息的快…
阅读更多...
螺蛳壳里做道场：老破机搭建的私人数据中心---Centos下Docker学习04(环境准备)

螺蛳壳里做道场：老破机搭建的私人数据中心---Centos下Docker学习04(环境准备)

4 创建docker容器 4.1创建网络 [rootlocalhost wutool]# docker network create -d macvlan --subnet192.168.137.0/24 --gateway192.168.137.2 --ip-range192.168.137.0/24 -o parentens33 nat 52af11381bfd655d175e4168265b2a507793e8fe48f119db846949ffd4dd27de [rootlocal…
阅读更多...
【每天学个新注解】Day 15 Lombok注解简解（十四）—@UtilityClass、@Helper

【每天学个新注解】Day 15 Lombok注解简解（十四）—@UtilityClass、@Helper

UtilityClass 生成工具类的注解 将一个类通过注解变成一个工具类&#xff0c;并没有什么用&#xff0c;本来代码中的工具类数量就极为有限&#xff0c;并不能达到减少重复代码的目的 1、如何使用 加在需要委托将其变为工具类的普通类上。 2、代码示例 例&#xff1a; Uti…
阅读更多...
设计模式之原型模式(通俗易懂--代码辅助理解【Java版】）

设计模式之原型模式(通俗易懂--代码辅助理解【Java版】）

文章目录 设计模式概述1、原型模式2、原型模式的使用场景3、优点4、缺点5、主要角色6、代码示例7、总结题外话关于使用序列化实现深拷贝 设计模式概述 创建型模式&#xff1a;工厂方法、抽象方法、建造者、原型、单例。 结构型模式有&#xff1a;适配器、桥接、组合、装饰器、…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023