【C++代码】链表

  • 算法：搜索、查找、排序、双指针、回溯、分治、动态规划、贪心、位运算、数学等。

  • 数据结构：数组、栈、队列、字符串、链表、树、图、堆、哈希表等。

  • 数据结构是为实现对计算机数据有效使用的各种数据组织形式，服务于各类计算机操作。不同的数据结构具有各自对应的适用场景，旨在降低各种算法计算的时间与空间复杂度，达到最佳的任务执行效率。常见的数据结构可分为「线性数据结构」与「非线性数据结构」，具体为：「数组」、「链表」、「栈」、「队列」、「树」、「图」、「散列表」、「堆」。数组是将相同类型的元素存储于连续内存空间的数据结构，其长度不可变。链表以节点为单位，每个元素都是一个独立对象，在内存空间的存储是非连续的。链表的节点对象具有两个成员变量：「值 val」，「后继节点引用 next」 。栈是一种具有 「先入后出」 特点的抽象数据结构，可使用数组或链表实现。通过常用操作「入栈 push()」,「出栈 pop()」，展示了栈的先入后出特性。队列是一种具有 「先入先出」 特点的抽象数据结构，可使用链表实现。通过常用操作「入队 push()」,「出队 pop()」，展示了队列的先入先出特性。

  • 树是一种非线性数据结构，根据子节点数量可分为 「二叉树」 和 「多叉树」，最顶层的节点称为「根节点 root」。以二叉树为例，每个节点包含三个成员变量：「值 val」、「左子节点 left」、「右子节点 right」 。图是一种非线性数据结构，由「节点（顶点）vertex」和「边 edge」组成，每条边连接一对顶点。根据边的方向有无，图可分为「有向图」和「无向图」。

    • 在这里插入图片描述

    • 表示图的方法通常有两种：邻接矩阵： 使用数组 vertices 存储顶点，邻接矩阵 edges 存储边；edges[i] [j] 代表节点 i+1 和 节点 j+1 之间是否有边。

    • vertices = [1, 2, 3, 4, 5]
edges = [[0, 1, 1, 1, 1],[1, 0, 0, 1, 0],[1, 0, 0, 0, 1],[1, 1, 0, 0, 1],[1, 0, 1, 1, 0]]

    • 邻接表： 使用数组 vertices 存储顶点，邻接表 edges 存储边。 edges 为一个二维容器，第一维 i 代表顶点索引，第二维 edges[i] 存储此顶点对应的边集和；例如 edges[0]=[1,2,3,4] 代表 vertices[0] 的边集合为 [1,2,3,4] 。

    • vertices = [1, 2, 3, 4, 5]
edges = [[1, 2, 3, 4],[0, 3],[0, 4],[0, 1, 4],[0, 2, 3]]

    • 邻接矩阵 VS 邻接表 ：

      邻接矩阵的大小只与节点数量有关，即 N 2 N^2 N2 ，其中 N 为节点数量。因此，当边数量明显少于节点数量时，使用邻接矩阵存储图会造成较大的内存浪费。因此，邻接表 适合存储稀疏图（顶点较多、边较少）； 邻接矩阵 适合存储稠密图（顶点较少、边较多）。

  • 散列表是一种非线性数据结构，通过利用 Hash 函数将指定的「键 key」映射至对应的「值 value」，以实现高效的元素查找。则可通过建立姓名为 key ，学号为 value 的散列表实现此需求，代码如下：

    • # 初始化散列表
dic = {}
# 添加 key -> value 键值对
dic["小力"] = 10001
dic["小特"] = 10002
dic["小扣"] = 10003
# 从姓名查找学号
dic["小力"] # -> 10001
dic["小特"] # -> 10002
dic["小扣"] # -> 10003

    • 实际的 Hash 函数需保证低碰撞率、 高鲁棒性等，以适用于各类数据和场景。

  • 堆是一种基于「完全二叉树」的数据结构，可使用数组实现。以堆为原理的排序算法称为「堆排序」，基于堆实现的数据结构为「优先队列」。堆分为「大顶堆」和「小顶堆」，大（小）顶堆：任意节点的值不大于（小于）其父节点的值。

    • 完全二叉树定义： 设二叉树深度为 k ，若二叉树除第 k 层外的其它各层（第 1 至 k−1 层）的节点达到最大个数，且处于第 k 层的节点都连续集中在最左边，则称此二叉树为完全二叉树。

  • 为包含 1, 4, 2, 6, 8 元素的小顶堆。将堆（完全二叉树）中的结点按层编号，即可映射到右边的数组存储形式。

    • 在这里插入图片描述

    • 通过使用「优先队列」的「压入 push()」和「弹出 pop()」操作，即可完成堆排序，实现代码如下：

    • from heapq import heappush, heappop
# 初始化小顶堆
heap = []
# 元素入堆
heappush(heap, 1)
heappush(heap, 4)
heappush(heap, 2)
heappush(heap, 6)
heappush(heap, 8)
# 元素出堆（从小到大）
heappop(heap) # -> 1
heappop(heap) # -> 2
heappop(heap) # -> 4
heappop(heap) # -> 6
heappop(heap) # -> 8

  • 算法复杂度旨在计算在输入数据量 N 的情况下，算法的「时间使用」和「空间使用」情况；体现算法运行使用的时间和空间随「数据大小 N 」而增大的速度。算法复杂度主要可从 时间 、空间 两个角度评价：

    • 时间： 假设各操作的运行时间为固定常数，统计算法运行的「计算操作的数量」 ，以代表算法运行所需时间；

    • 空间： 统计在最差情况下，算法运行所需使用的「最大空间」；

    • 根据输入数据的特点，时间复杂度具有「最差」、「平均」、「最佳」三种情况，分别使用 O , Θ , Ω 三种符号表示。

    • 根据从小到大排列，常见的算法时间复杂度主要有：

    • O ( 1 ) < O ( l o g N ) < O ( N ) < O ( N l o g N ) < O ( N 2 ) < O ( 2 N ) < O ( N ! ) O(1)<O(logN)<O(N)<O(NlogN)<O(N^2)<O(2^N)<O(N!) O(1)<O(logN)<O(N)<O(NlogN)<O(N2)<O(2N)<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:vector<int> reverseBookList(ListNode* head) {stack<int> st;vector<int> ve;while(head){st.push(head->val);head = head->next;}while(!st.empty()){ve.push_back(st.top());st.pop();}return ve;}
};

  • 反转的实现就是一点小技巧，需要用到三个指针变量，类似于两个数交换的思想，层次递进。现在假设定义pre、phead、temp三个指针变量，用phead指向链表的头结点，而pre代表phead的前一个节点。具体实现代码如下：

    • ListNode* InvertList(link head){ListNode* pre,phead,temp;phead = &head;  //将phead指向链表头，做游标使用pre = NULL;  //pre为头指针之前的节点while(phead != NULL){temp = pre;pre = phead;phead = phead->next;pre->next = temp;  //pre接到之前的节点 }return pre; 
}

  • 利用递归，先递推至链表末端；回溯时，依次将节点值加入列表，即可实现链表值的倒序输出。

    • /*** 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:vector<int> res;void track(ListNode* head){if(head==nullptr){return ;}track(head->next);res.push_back(head->val);}vector<int> reverseBookList(ListNode* head) {track(head);return res;}
};

题目：给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。返回删除后的链表的头节点。

  • /*** Definition for singly-linked list.* struct ListNode {*     int val;*     ListNode *next;*     ListNode(int x) : val(x), next(NULL) {}* };*/
class Solution {
public:ListNode* deleteNode(ListNode* head, int val) {ListNode* prenode = new ListNode(-1);prenode->next = head;ListNode* temp = prenode;while(temp->next){if(temp->next->val == val){temp->next = temp->next->next;break;}temp = temp->next;}return prenode->next;}
};

  • 本题删除值为 val 的节点分需为两步：定位节点、修改引用。定位节点： 遍历链表，直到 head.val == val 时跳出，即可定位目标节点。修改引用： 设节点 cur 的前驱节点为 pre ，后继节点为 cur.next ；则执行 pre.next = cur.next ，即可实现删除 cur 节点。对于头节点没有前驱，可以设置一个虚拟节点。

题目：给定一个头节点为 head 的单链表用于记录一系列核心肌群训练编号，请将该系列训练编号 倒序 记录于链表并返回。

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

  • 时间复杂度 O(N) ： 遍历链表使用线性大小时间。空间复杂度 O(1) ： 变量 pre 和 cur 使用常数大小额外空间。

题目：给定一个头节点为 head 的链表用于记录一系列核心肌群训练项目编号，请查找并返回倒数第 cnt 个训练项目编号。

  • /*** 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* trainingPlan(ListNode* head, int cnt) {int n=0;ListNode* node = nullptr;for(node=head;node;node=node->next){n++;}for(node = head;n>cnt;n--){node = node->next;}return node;}
};

  • 两次遍历，用双指针只需要一次遍历

  • /*** 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* trainingPlan(ListNode* head, int cnt) {ListNode* left =head;ListNode* right = head;while(right && cnt>0){right = right->next;cnt--;}while(right){right = right->next;left = left->next;}return left;}
};

题目：给定两个以 有序链表 形式记录的训练计划 l1、l2，分别记录了两套核心肌群训练项目编号，请合并这两个训练计划，按训练项目编号 升序 记录于链表并返回。注意：新链表是通过拼接给定的两个链表的所有节点组成的。

  • /*** 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* trainningPlan(ListNode* l1, ListNode* l2) {if(!l1){return l2;}if(!l2)return l1;ListNode* res;ListNode* head;if(l1->val < l2->val){head = l1;l1 = l1->next;}else{head = l2;l2 = l2->next;}res = head;while(l1 && l2){if(l1->val < l2->val){res->next = l1;l1 = l1->next;}else{res->next = l2;l2 = l2->next;}res = res->next;}if(l1){res->next = l1;}if(l2){res->next = l2;}return head;}
};

  • 链表 l1 , l2 是 递增 的，因此容易想到使用双指针 l1 和 l2 遍历两链表，根据 l1.val 和 l2.val 的大小关系确定节点添加顺序，两节点指针交替前进，直至遍历完毕。引入伪头节点： 由于初始状态合并链表中无节点，因此循环第一轮时无法将节点添加到合并链表中。解决方案：初始化一个辅助节点 dum 作为合并链表的伪头节点，将各节点添加至 dum 之后。

  • 在这里插入图片描述

  • /*** 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* trainningPlan(ListNode* l1, ListNode* l2) {ListNode* dumy = new ListNode(0);ListNode* cur =dumy;while(l1 && l2){if(l1->val < l2->val){cur->next = l1;l1 = l1->next;}else{cur->next = l2;l2 = l2->next;}cur = cur->next;}cur->next = l1!=nullptr?l1:l2;return dumy->next;}
};

题目：某教练同时带教两位学员，分别以链表 l1、l2 记录了两套核心肌群训练计划，节点值为训练项目编号。两套计划仅有前半部分热身项目不同，后续正式训练项目相同。请设计一个程序找出并返回第一个正式训练项目编号。如果两个链表不存在相交节点，返回 null 。

  • /*** 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* pa = headA;// ListNode* pb = headB;if(!headB || !headA){return NULL;}ListNode* cur =headA,*res = NULL;while(cur){cur->val *= -1;cur = cur->next;}cur = headB;while(cur){if(cur->val < 0){res = cur;break;}cur = cur->next;}cur = headA;while(cur){cur->val *= -1;cur = cur->next;}return res;}
};

  • 在这里插入图片描述

  • /*** 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) {if(!headA || !headB){return nullptr;}ListNode *pa=headA,*pb=headB;while(pa != pb){pa = pa==nullptr?headB:pa->next;pb = pb==nullptr?headA:pb->next;}return pa;}
};

题目：请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。

  • 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。

  • /*
// 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) {if(head==nullptr){return nullptr;}for(Node* node = head;node!=nullptr;node=node->next->next){Node* newnode = new Node(node->val);newnode->next = node ->next;node->next = newnode;}for(Node* node =head;node!=nullptr;node = node->next->next){Node* newnode = node->next;newnode->random = (node->random != nullptr)?node->random->next:nullptr;}Node* newhead = head->next;for(Node* node=head;node!=nullptr;node = node->next){Node* newnode = node->next;node->next = node->next->next;newnode->next = (newnode->next!=nullptr)?newnode->next->next:nullptr;}return newhead;        }
};

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

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

解决 Invalid bound statement (not found): XXXX 异常

解决 Invalid bound statement (not found): XXXX 异常

解决Invalid bound statement not found 异常 异常环境解决 异常环境 1、异常提示找不到 listQuery2方法 Caused by: org.apache.ibatis.binding.BindingException: Invalid bound statement (not found): com.huaw.mapper.excel.ExcelWorkBookMapper.listQuery2 2、MyBatis…
阅读更多...
超越噪音，让音乐重获新生：iZotope RX 10音频降噪修复软件

超越噪音，让音乐重获新生：iZotope RX 10音频降噪修复软件

在音乐制作或者音频处理的过程中&#xff0c;噪音往往是一个让人头痛的问题。无论是环境噪音&#xff0c;还是设备产生的噪音&#xff0c;都会对音频质量产生重大影响。而现在&#xff0c;我们有了iZotope RX 10&#xff0c;这款专业的音频降噪修复软件&#xff0c;可以将你从噪…
阅读更多...
基于单片机的肺活量检测系统（论文+源码）

基于单片机的肺活量检测系统（论文+源码）

1.系统设计 在基于单片机的肺活量检测系统中&#xff0c;在硬件上整个系统通过利用主控制器STC89C52单片机来实现对整个系统进行控制的功能&#xff0c;通过采用LCD1602实现实时液晶显示数据的功能&#xff0c;通过肺活量传感器XGZP6847ADC0832实现监测肺活量的工作&#xff0…
阅读更多...
【LM、LLM】浅尝二叉树在前馈神经网络上的应用

【LM、LLM】浅尝二叉树在前馈神经网络上的应用

前言 随着大模型的发展&#xff0c;模型参数量暴涨&#xff0c;以Transformer的为组成成分的隐藏神经元数量增长的越来越多。因此&#xff0c;降低前馈层的推理成本逐渐进入视野。前段时间看到本文介绍的相关工作还是MNIST数据集上的实验&#xff0c;现在这个工作推进到BERT上…
阅读更多...
使用Linux JumpServer堡垒机本地部署与远程访问

使用Linux JumpServer堡垒机本地部署与远程访问

&#x1f308;个人主页&#xff1a;聆风吟 &#x1f525;系列专栏&#xff1a;网络奇遇记、Cpolar杂谈 &#x1f516;少年有梦不应止于心动&#xff0c;更要付诸行动。 文章目录 &#x1f4cb;前言一. 安装Jump server二. 本地访问jump server三. 安装 cpolar内网穿透软件四. 配…
阅读更多...
发现有一个会Python的男友魅力值杠杠的！！！

发现有一个会Python的男友魅力值杠杠的！！！

Python能做什么&#xff1f; 可以做日常任务&#xff0c;比如自动备份你的MP3&#xff0c;可以做网站&#xff0c;很多著名的网站像知乎、YouTube就是Python写的&#xff0c; 可以做网络游戏的后台&#xff0c;很多在线游戏的后台都是Python开发的。 上面说的这些本人并没有实…
阅读更多...
免费获取GPT-4的五种工具

免费获取GPT-4的五种工具

不可否认&#xff0c;由OpenAI带来的GPT-4已是全球最受欢迎的、功能最强大的大语言模型&#xff08;LLM&#xff09;之一。大多数人都需要使用ChatGPT Plus的订阅服务去访问GPT-4。为此&#xff0c;他们通常需要每月支付20美元。那么问题来了&#xff0c;如果您不想每月有这笔支…
阅读更多...
【SpringBoot篇】阿里云OSS—存储文件的利器

【SpringBoot篇】阿里云OSS—存储文件的利器

文章目录 &#x1f339;什么是阿里云OSS⭐阿里云OSS的优点 &#x1f3f3;️‍&#x1f308;为什么要使用云服务OSS&#x1f384;使用步骤⭐OSS开通⭐参考官方SDK &#x1f354;编写代码⭐上传文件 &#x1f339;综合案例 &#x1f339;什么是阿里云OSS 阿里云对象存储&#xf…
阅读更多...
转录组学习第5弹-比对参考基因组

转录组学习第5弹-比对参考基因组

比对参考基因组 在构建文库的过程中需要将DNA片段化&#xff0c;因此测序得到的序列只是基因组的部分序列。为了确定测序reads在基因组上的位置&#xff0c;需要将reads比对回参考基因组上&#xff0c;这个步骤叫做比对&#xff0c;即文献中所提到的alignment或mapping。包括基…
阅读更多...
面试题：说说什么是本地缓存、分布式缓存以及多级缓存，它们各自的优缺点？

面试题：说说什么是本地缓存、分布式缓存以及多级缓存，它们各自的优缺点？

文章目录 前言一、缓存的概念&#xff08;什么是缓存&#xff09;二、为什么要用缓存&#xff08;为什么要用redis作为缓存&#xff09;三、缓存的分类有哪些1、本地缓存2、分布式缓存3、多级缓存 总结 前言 像MySql等传统的关系型数据库已经不能适用于所有的业务场景&#xf…
阅读更多...
JSP EL表达式之 empty

JSP EL表达式之 empty

好 本文我们还是继续说EL表达式 我们来讲一个非空判断的好手 empty 我们直接编写代码如下 <% page contentType"text/html; charsetUTF-8" pageEncoding"UTF-8" %> <%request.setCharacterEncoding("UTF-8");%> <!DOCTYPE html&…
阅读更多...
CSS-长度单位篇

CSS-长度单位篇

px&#xff1a;像素em&#xff1a;相对元素font-size的倍数rem&#xff1a;相对根字体大小&#xff0c;html标签就是根%&#xff1a;相对父元素计算 注意&#xff1a;CSS中设置长度&#xff0c;必须加单位&#xff0c;否则样式无效&#xff01;
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023