链表 --＞总结

已于 2023-02-05 18:03:47 修改
阅读量636 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： leetcode题解 文章标签： 链表 数据结构
于 2019-07-22 15:02:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Android_chunhui/article/details/96272351

文章目录

1. 头插法尾插法

 //头插法是insert反序，只需要头指针
 ListNode* head_insert(vector<int>& nums)
 {
   
   
	 ListNode* head = NULL;
	 for (
了解本专栏 订阅专栏 解锁全文 超级会员免费看
(一)Android数据结构学习之链表
u010618194的博客
08-02 6290
需要看本系列其他文章的请转到： - (一)Android数据结构学习与算法之链表 - (二)Android数据结构学习与算法之数组 - (三)Android数据结构学习与算法之队列前言我们都知道Android是基于java的，Java中实现了很多数据结构，像我们最常使用的数组、List都是数据结构，当我们使用的时候可能会觉得这些东西真是方便，但是并不知道其中原理，很多好的公司招人会
笔试题之链表逆序A->B->C to C->B>A
09-21
例如，给定一个链表A->B->C，逆序后应变为C->B->A。在链表中，每个节点包含数据和指向下一个节点的指针。逆序链表的操作涉及到改变这些指针的方向，以达到新的顺序。 有多种方法可以实现链表逆序，包括迭代法和递归...
看得见的数据结构Android版之单链表篇
weixin_34148508的博客
11-24 299
零、前言 1.前面用数组实现了表结构,也分析了数组表的局限性(头部修改困难) 2.今天来讲另一种数据结构：单链表，它是一种最简单的动态数据结构 3.链表有点像火车，一节拴着一节,想要在某节后加一节，打开连接处，再拴上就行了 4.本例操作演示源码：希望你可以和我在Github一同见证：DS4Android的诞生与成长，欢迎star 1.留图镇楼：单链表的最终实现的操作效果: 2.对于单链表简...
android知识回顾-----单向链表
cenfei78325747的专栏
11-13 2682
一.单向链表的反转       【尊重原创，转载请注明出处】http://blog.youkuaiyun.com/guyuealian/article/details/51119499 （一）单链表的结点结构:　       data域：存储数据元素信息的域称为数据域；　     next域：存储直接后继位置的域称为指针域，它是存放结点的直接后继的地址（位置）的指针域（链域）。
Android LinkedList★★
zenmela2011的专栏
04-05 1141
1. LinkedList ①LinkedList是一种可以在任何位置进行高效地插入和移除操作的有序序列，它是基于双向链表实现的。 ②LinkedList 实现 List 接口，能对它进行队列操作；实现 Deque 接口，即能将LinkedList当作双端队列使用；实现了Cloneable接口，即覆盖了函数clone()，能克隆；实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。 ③LinkedList 是非同步的。 2.LinkedList.
Android中的双向链表
GetnextWindow的专栏
07-14 2564
1.看源码必须搞懂Android的数据结构。在init源代码中双向链表listnode使用很多，它只有prev和next两个指针，没有任何数据成员。这个和linux内核的list_head如出一辙，由此可见安卓深受linux内核的影响的。本来来分析一下这个listnode数据结构。 这里需要考虑的一个问题是，链表操作都是通过listnode进行的，但是那不过是个连接件，如果我们手上有个宿主结构，
链表-使用C语言实现非循环双向链表-带头结点+尾结点.zip
03-13
current->next->prev = current->prev; free(current); } ``` 最后，为了完整地使用这些操作，我们需要提供一个销毁链表的函数，释放所有节点的内存： ```c void destroyList(Node* head) { Node* current = ...
链表-使用PHP实现的循环链表数据结构.zip
03-13
$newNode->next = $this->head; // 形成循环 } else { $current = $this->head; while ($current->next != $this->head) { $current = $current->next; } $newNode = new Node($data); $current->next = $...
python-leetcode面试题解之第61题旋转链表-题解.zip
03-19
例如，给定链表1->2->3->4->5->NULL和k=2，旋转后链表变为3->4->5->1->2->NULL。 ### 链表基础知识 在开始解题之前，我们需要了解链表的基本概念。链表是一种线性数据结构，由一系列节点组成，每个节点包含数据和...
android中定义链表,Android双向链表插入删除基本应用
weixin_31139479的博客
05-26 167
释放双眼，带上耳机，听听看~！双链表其实 也没什么 只是多了一个前置链而已双链表的定义struct DNode{int data;struct DNode *next;struct DNode *pre;};单链表的定义view plaincopystruct DNode{int data;struct DNode *next;};其他的可以看上一篇博客 大致相同#ifndef HEAD_H#de...
数据结构之双向链表
12-28
这是一个双向链表的实现，集成了删除、添加以及迭代功能
【Android开发】之【链表数据结构 源码示例】
软件开发、电子设计
06-04 975
1．        链结点 在链表中，每个数据项都被包含在‘点“中，一个点是某个类的对象，这个类可认叫做LINK。因为一个链表中有许多类似的链结点，所以有必要用一个不同于链表的类来表达链结点。每个LINK对象中都包含一个对下一个点引用的字段（通常叫做next）但是本身的对象中有一个字段指向对第一个链结点的引用 单链表 用一组地址任意的存储单元存放线性表中的数据元素。 　　以元素(数据元素的
android中定义链表,Android中的双向链表
weixin_34620163的博客
05-26 436
1.看源码必须搞懂Android的数据结构。在init源代码中双向链表listnode使用很多，它只有prev和next两个指针，没有任何数据成员。这个和linux内核的list_head如出一辙，由此可见安卓深受linux内核的影响的。本来来分析一下这个listnode数据结构。这里需要考虑的一个问题是，链表操作都是通过listnode进行的，但是那不过是个连接件，如果我们手上有个宿主结构，那当...
看得见的数据结构Android版之双链表篇
张风捷特烈的博客
11-25 415
零、前言 1.上一篇分析了单链表，链表是一种数据结构，用来承载数据，每个表节点装载一个数据元素 2.双链表是每个节点除了数据元素外还分别持有前、后两个节点的引用 3.为了统一节点的操作，一般在真实链表的首尾各加一个虚拟节点，称为头节点和尾节点 4.如果说单链表是一列火车，那双链表就是一辆双头加固版火车，java中的LinkedList底层便是此结构 5....
android 线程安全链表,具有细粒度锁的线程安全链表
weixin_35720393的博客
05-29 167
在一个程序中,我有一个M类:class M{/*very big immutable fields*/int status;};我需要一个M型对象的链表.三种类型的线程正在访问列表:生产者:生成并将对象追加到列表的末尾.所有新生成的对象都具有status = NEW.(操作时间= O(1))消费者:在列表的开头使用对象.如果消费者具有status = CONSUMER_ID,则消费者可以使用该对象...
android中定义链表,Android学习之数据结构
weixin_29028145的博客
05-26 251
一、概念计算机储存数据，组织数据的一种方式。二、思维导图数据结构思维导图三、详情1.数组①概念存储多个相同类型的数据的集合。②特点a)数组中的数据元素可以是基本数据类型，也可以是引用数据类型；b)数组具有下标，下标从0开始计数，用于快速获取数组中的数据，比如a[0]，表示数组中的第一个数据；c)数组在创建的时候，需要在内存中申请一段固定长度的内存，如果申请的长度超过内存剩余的长度，则容易产生碎片，...
Android简单单链表,单链表 知识点学习--Android地基系列(一)
weixin_30512965的博客
06-04 356
};1、求链表中结点个数思路：若链表为空，返回0；循环判断链表下一个指针是否为空，no，长度++(初始化用unsigned int length = 0)，直到下一个为null，返回长度// 求单链表中结点的个数unsigned int GetListLength(ListNode * pHead){if(pHead == NULL)return 0;unsigned int mLength =...
android单链表结构,安卓数据结构01-顺序表与链表
weixin_26516551的博客
06-02 371
安卓数据结构01-顺序表与链表前言1 什么是数据结构数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术有关。数据的逻辑结构：指反映数据元素之间的逻辑关系的数据结构，其中的逻辑关系是指数据元素之间的前后关系，而与他们在计算机中的存储位置无关。逻辑结构包括...
链表
轻描时光
03-23 195
链表是有序的列表，但是它在内存中是存储如下 小结: 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域：指向下一个节点. 如图：发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 单链表(带头结点) 逻辑结构示意图如下 使用带head头的单向链表实现 –水浒英雄排行榜管理 完成对英雄人物的增删改查操作 第一...
两个非降序链表的并集，例如将链表1->2->3 和 2->3->5 并为 1->2->3->5，只能输出结果，不能修改两个链表的数据，用c语言或c++
最新发布
03-16
<think>好的，我现在需要解决用户的问题：如何用C/C++实现两个非降序链表的并集操作，同时不修改原有链表结构。首先，我需要明确用户的需求。用户提到“并集”，通常集合的并集是指所有元素的合集，且不重复。但链表是非降序的，可能需要合并后保持有序，并且去重。同时，不能修改原链表，所以必须创建新节点。 首先，我应该回忆链表操作的基本方法。合并两个有序链表通常使用双指针法，逐个比较节点值，选择较小的加入新链表。但并集的话，需要处理重复元素，即当两个链表有相同元素时，只保留一个。例如，链表1是1->2->4，链表2是2->3->4，并集应该是1->2->3->4。 接下来，我需要考虑如何不修改原链表。这意味着每次需要创建新节点，复制原节点的值，而不是直接链接原节点。这可以避免修改原链表的结构。 然后，处理重复元素的问题。在合并过程中，当发现当前节点的值与已加入新链表的最后一个节点的值相同时，应该跳过，不添加到新链表中。例如，如果新链表的最后一个节点是2，而当前比较的两个节点都是2，那么只添加一次。 接下来，我需要设计算法的步骤： 1. 初始化两个指针分别指向两个链表的头节点。 2. 创建一个哑节点作为新链表的起始点，方便处理。 3. 使用循环比较两个指针当前节点的值，选择较小的节点，复制其值创建新节点，并添加到新链表中。 4. 如果遇到相等的值，只添加一个，并同时移动两个指针。 5. 每次添加新节点后，检查是否与新链表最后一个节点的值相同，如果相同则跳过，避免重复。 6. 当其中一个链表遍历完后，将另一个链表的剩余部分依次处理，同样要检查重复。 需要考虑边界情况，例如其中一个链表为空，或者两个链表有大量重复元素。例如，链表1是1->1->2，链表2是1->2->3，并集应该是1->2->3。 此外，关于数据结构，链表节点的结构通常包含一个值域和一个指向下一个节点的指针。在C++中，可以使用结构体或类来定义节点。 现在，我需要考虑代码的具体实现。例如，如何遍历链表，如何创建新节点，如何避免重复。在合并过程中，每次比较两个当前节点的值，较小的那个被选中，但如果该值与新链表的最后一个节点值相同，则跳过。或者，在合并过程中，即使值相同，也需要合并一次，但之后跳过所有相同的值。 例如，当处理链表A的节点和链表B的节点时，如果A->data小于B->data，那么将A->data加入新链表，然后移动A指针，直到下一个不同的值。同样，如果B->data较小，则处理B。如果两者相等，则加入一个，并移动两个指针到下一个不同的值。这种方法可以避免重复，但需要处理连续的重复值，比如链表中有多个相同的元素。 或者，在合并过程中，每次比较当前节点的值，选择较小的，然后移动对应的指针，并在添加到新链表时检查是否与上一个节点重复。这种方法可能在合并后的链表中处理重复，例如，当添加新节点时，如果新节点的值等于当前新链表的最后一个节点的值，则不添加。 这两种方法都需要处理重复的情况，可能第一种方法在合并时就去重更高效，因为可以跳过原链表中的重复元素。例如，如果原链表中有多个连续的相同元素，比如1->1->2，那么在合并时，遇到第一个1后，可以跳过后面所有的1，直接处理2。这样可以减少后续比较的次数。 因此，可能的步骤是： - 使用双指针p和q分别指向链表1和链表2的头节点。 - 创建一个哑节点dummy作为新链表的起点，和一个尾指针tail指向dummy。 - 循环直到p或q为空： - 比较p->val和q->val： - 如果p->val < q->val： - 如果新链表的尾部的值不等于p->val，则创建新节点，添加到尾部，更新tail。 - 移动p到下一个节点，直到p->val不等于当前值（跳过重复）。 - 否则 if q->val < p->val： - 类似处理q - 如果相等： - 如果新链表的尾部的值不等于p->val，创建新节点，添加到尾部，更新tail。 - 移动p和q到下一个不同的值。 - 处理剩下的链表，同样跳过重复元素，添加到新链表，并检查是否重复。 这种方法的关键在于，每次处理一个节点后，跳过原链表中所有相同的元素，这样可以避免在后续步骤中重复处理。例如，当p指向的节点是1，且链表后面还有多个1，那么处理完这个1后，p应该移动到第一个不为1的节点，这样后续比较时就不会再次处理这些1了。 这样的处理方式可以确保并集中的元素不重复，并且保持非降序顺序。同时，由于每次都是创建新节点，原链表的结构不会被修改。 现在，我需要将这个思路转化为具体的代码。例如，在C++中，函数可能接受两个链表的头节点，返回新链表的头节点。需要注意的是，当处理链表中的重复元素时，需要使用循环来跳过相同的节点。例如： 处理链表1的当前节点p时： int current_val = p->val; while (p != nullptr && p->val == current_val) { p = p->next; } 同样的处理适用于链表2的节点q。 然后在合并过程中，每次比较当前p和q的值，选择较小的，并且跳过所有相同的节点，只添加一次到新链表中。 这样，整个合并并去重的过程可以在O(n + m)的时间复杂度内完成，其中n和m是两个链表的长度。 接下来，需要考虑代码的编写。例如，创建新链表时，需要使用new来分配新节点，并且正确连接next指针。同时，要注意处理空链表的情况，例如其中一个链表为空，或者两个都为空。 例如，如果链表1为空，则并集就是链表2的去重结果。反之亦然。 现在，编写代码的大致步骤： 1. 定义链表节点结构： struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(nullptr) {} }; 2. 函数实现： ListNode* unionOfTwoLists(ListNode* l1, ListNode* l2) { ListNode dummy(0); ListNode* tail = &dummy; ListNode* p = l1; ListNode* q = l2; while (p && q) { if (p->val < q->val) { // 处理p的值 int val = p->val; if (tail == &dummy || tail->val != val) { tail->next = new ListNode(val); tail = tail->next; } // 跳过所有相同的p节点 while (p && p->val == val) { p = p->next; } } else if (q->val < p->val) { // 处理q的值 int val = q->val; if (tail == &dummy || tail->val != val) { tail->next = new ListNode(val); tail = tail->next; } // 跳过所有相同的q节点 while (q && q->val == val) { q = q->next; } } else { // 两者相等的情况 int val = p->val; if (tail == &dummy || tail->val != val) { tail->next = new ListNode(val); tail = tail->next; } // 跳过p和q中所有相同的节点 while (p && p->val == val) { p = p->next; } while (q && q->val == val) { q = q->next; } } } // 处理剩下的p或q中的节点 while (p) { int val = p->val; if (tail == &dummy || tail->val != val) { tail->next = new ListNode(val); tail = tail->next; } while (p && p->val == val) { p = p->next; } } while (q) { int val = q->val; if (tail == &dummy || tail->val != val) { tail->next = new ListNode(val); tail = tail->next; } while (q && q->val == val) { q = q->next; } } return dummy.next; } 这段代码的思路是，每次处理当前p和q中的较小值，并跳过所有相同的节点。同时，在添加到新链表时检查是否与最后一个节点的值重复，避免添加重复元素。需要注意的是，当新链表为空（即tail还是dummy节点时），直接添加，否则比较tail的值。 这样，最终得到的新链表就是两个原链表的并集，且保持非降序，不修改原链表的结构。 现在，需要测试这个代码是否正确。例如，测试用例： 链表1：1 -> 2 -> 4 链表2：2 -> 3 ->4 预期结果：1 -> 2 ->3 ->4 另一个测试用例： 链表1：1 ->1 ->2 链表2：1 ->2 ->3 预期结果：1 ->2 ->3 如果链表1或链表2为空的情况，比如链表1为空，链表2为2->2->3，结果应为2->3。 可能的问题：当处理剩下的链表时，是否需要同样跳过重复元素？例如，剩下的链表可能有多个重复的元素，代码中的处理是否能够正确去重。例如，剩下的p链表是3->3->4，那么在处理时会先取3，创建节点，然后跳过所有3，接着处理4。 是的，代码在处理剩余链表时，同样会跳过所有重复的值，只添加一次。 总结：这个算法的时间复杂度是O(n + m)，因为每个节点只会被访问一次。空间复杂度是O(1)，如果不考虑结果链表所占用的空间，因为结果链表需要创建新的节点，所以空间复杂度是O(n + m)（最坏情况下，所有元素都不重复）。 用户可能需要的是C语言的实现，但C++的代码结构类似，只是内存分配使用malloc。此外，需要注意内存管理，避免内存泄漏。 最后，用户的问题中提到的参考引用是关于链表合并的，可能涉及如何遍历链表和合并操作。因此，本解决方案符合用户的需求，并且没有修改原链表。</think>### 分步解答 要实现两个非降序链表的并集操作且不修改原链表，可以通过以下步骤完成： 1. **定义链表节点结构** 使用结构体表示链表节点，包含值域和指针域： ```c struct ListNode { int val; struct ListNode* next; }; ``` 2. **双指针遍历链表** 初始化指针`p`和`q`分别指向两个链表的头节点，逐个比较节点值： - 若`p->val < q->val`，将`p->val`加入新链表，并跳过后续所有相同值的节点。 - 若`q->val < p->val`，将`q->val`加入新链表，并跳过后续所有相同值的节点。 - 若两者相等，将值加入新链表，并同时跳过两个链表中所有相同值的节点。 3. **去重逻辑** 每次插入新节点时，检查是否与当前结果链表的最后一个节点值重复，避免重复添加。 4. **处理剩余节点** 当其中一个链表遍历完毕后，将另一个链表的剩余节点按非降序合并到结果链表中，同样需要跳过重复值。 ### 完整代码实现（C++） ```cpp #include <iostream> using namespace std; struct ListNode { int val; ListNode* next; ListNode(int x) : val(x), next(nullptr) {} }; ListNode* unionOfTwoLists(ListNode* l1, ListNode* l2) { ListNode dummy(0); ListNode* tail = &dummy; ListNode* p = l1; ListNode* q = l2; while (p && q) { if (p->val < q->val) { int val = p->val; if (tail->val != val) { tail->next = new ListNode(val); tail = tail->next; } while (p && p->val == val) p = p->next; } else if (q->val < p->val) { int val = q->val; if (tail->val != val) { tail->next = new ListNode(val); tail = tail->next; } while (q && q->val == val) q = q->next; } else { int val = p->val; if (tail->val != val) { tail->next = new ListNode(val); tail = tail->next; } while (p && p->val == val) p = p->next; while (q && q->val == val) q = q->next; } } while (p) { int val = p->val; if (tail->val != val) { tail->next = new ListNode(val); tail = tail->next; } while (p && p->val == val) p = p->next; } while (q) { int val = q->val; if (tail->val != val) { tail->next = new ListNode(val); tail = tail->next; } while (q && q->val == val) q = q->next; } return dummy.next; } // 辅助函数：打印链表 void printList(ListNode* head) { if (!head) cout << "NULL"; while (head) { cout << head->val; if (head->next) cout << " "; head = head->next; } cout << endl; } int main() { // 测试用例 ListNode* l1 = new ListNode(1); l1->next = new ListNode(2); l1->next->next = new ListNode(4); ListNode* l2 = new ListNode(2); l2->next = new ListNode(3); l2->next->next = new ListNode(4); ListNode* result = unionOfTwoLists(l1, l2); printList(result); // 输出：1 2 3 4 return 0; } ``` ### 关键点说明 - **时间复杂度**：$O(n + m)$，其中$n$和$m$为两个链表的长度，每个节点仅访问一次[^1]。 - **空间复杂度**：$O(1)$（不计结果链表占用的空间）。 - **去重逻辑**：通过跳过原链表中的重复元素，保证结果链表中每个值唯一。 - **不修改原链表**：通过创建新节点实现结果链表，原链表指针仅用于遍历。 ---
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值