《算法之美》の链表问题の两链表相交问题

最新推荐文章于 2024-09-20 15:35:45 发布
最新推荐文章于 2024-09-20 15:35:45 发布
阅读量54 收藏
点赞数
文章标签： 数据结构与算法

编程判断两个链表是否相交

问题：给出两个单向链表的头指针，比如head1和head2，判断这两个链表是否相交。这里给出简化问题，假设两个链表均不带环。

解答：首先了解一下这个问题的工程实践，例如在一个大的系统中，如果出现两个链表相交的情况，一旦程序释放了其中的一个链表的所有节点，那样就会造成第二个链表信息的丢失。因此，我们需要在释放一个链表之前知道是否有其他链表与当前链表相交。

直观的想法：

判断第一个链表的每一个节点是否在第二个链表中，这需要O(Length(head1)*Length(head2))的时间复杂度，需要改进；

利用计数的方法：

如果两个链表相交，那么这两个链表存在共同的节点。而节点地址是节点的唯一标识。因此，我们只需判断两个链表中是否存在地址一致的节点即可。一个简单的方法是对第一个链表的节点地址进行哈希排序，建立哈希表，然后针对第二个链表的每个节点的地址查询哈希表，如果它在哈希表中出现说明两个链表相交。这个方法的时间复杂度是O(Length(head1)+Length(head2))，但是它同时需要附加O(Length(head1))的存储空间，以存放哈希表。

对问题进行转化：

由于两个链表没有环，我们可以将第二个链表接在第一个链表后面，如果得到的链表有环，说明这两个链表相交。否则，这两个链表不相交。因此，这就把问题转化为判断链表是否有环了。

如果这个新链表有环，那么第二个链表的表头一定在环上，我们从第二个链表开始遍历，看是否会回到起始点就可以判断出来了。最后我们还得记住将链表恢复原状，去掉第一个链表指向第二个链表表头的指针。

这个算法的时间复杂度是线性的，且只需要常数的空间。

问题的最终解决方案：

抓住本质：如果两个没有环的链表相交于某一点，那么在这个节点之后的所有节点都是这两个链表所共有的。如果两个链表相交，那么最后一个节点一定是共有的，因此，先遍历第一个链表，记住最后一个节点；再遍历第二个链表，到最后一个节点时和第一个链表的最后节点比较，如果相同，则相交，否则不相交。

这个算法时间复杂度是O(Length(head1)+Length(head2))，且仅用了一个额外的指针来存放第一个链表的最后一个节点。

完整代码如下：

#include <iostream>

#include <assert.h>

struct ListNode

{

int m_nKey;

ListNode* m_pNext;

};

void InitList(ListNode** head)

{

*head = (ListNode*)malloc(sizeof(ListNode));

(*head)->m_pNext = NULL;

}

void InsertList(ListNode* head, int data)

{

assert(head != NULL);

ListNode* pNewNode = (ListNode*)malloc(sizeof(ListNode));

pNewNode->m_nKey = data;

pNewNode->m_pNext = head->m_pNext;

head->m_pNext = pNewNode;

}

bool IsListIntercource(ListNode* head1, ListNode* head2)

{

if(head1 == NULL || head2 == NULL)

return false;

ListNode* pNode = head1;

while(pNode->m_pNext != NULL)

{

if(pNode->m_pNext->m_pNext == NULL)

{

pNode = pNode->m_pNext;

break;

}

pNode = pNode->m_pNext;

}

if((head2->m_pNext == NULL) && (pNode == head2))

return true;

while(head2->m_pNext != NULL)

{

if(head2->m_pNext->m_pNext == NULL)

{

if(pNode == head2->m_pNext)

return true;

else

return false;

}

head2 = head2->m_pNext;

}

}

int main()

{

ListNode* pListHead1 = NULL;

ListNode* pListHead2 = NULL;

InitList(&pListHead1);

InitList(&pListHead2);

//建立两个链表

for(int i=9; i>=0; i--)

{

InsertList(pListHead1, i);

InsertList(pListHead2, i);

}

//新建一个节点

ListNode* pListNode = (ListNode*)malloc(sizeof(ListNode));

pListNode->m_nKey = 100;

pListNode->m_pNext = NULL;

ListNode* pTemp = pListHead1;

while(pTemp->m_pNext != NULL)

{

pTemp = pTemp->m_pNext;

}

pTemp->m_pNext = pListNode; //将新节点接在链表后面

pTemp = pListHead2;

while(pTemp->m_pNext != NULL)

{

pTemp = pTemp->m_pNext;

}

pTemp->m_pNext = pListNode; //将新节点接在链表后面

//判断两个链表是否相交

if(IsListIntercource(pListHead1, pListHead2))

{

std::cout<<"两个链表相交"<<std::endl;

}

else

{

std::cout<<"两个链表不相交"<<std::endl;

}

system("pause");

return 0;

}

=======================================================

扩展问题：两个单向链表，编程找出它们的第一个公共节点

解答：在上一题中已经提到，如果两个链表有一个公共节点，那么该公共节点之后的所有节点都是重合的，那么，它们的最后一个节点必然也是重合的。因此，判断两个链表是否有重复部分，只要分别遍历两个链表的最后一个节点。如果两个尾节点是一样的，那么两个链表重合，否则两个链表没有公共的节点。

顺着上面的思路，顺序变量两个链表到尾节点时，我们并不能保证在两个链表上同时到达尾节点。这是因为两个链表长度不一定一样。如果假设链表1比链表2多x个节点，我们可以先在链表1上遍历前x个节点，之后再和链表2同步遍历，这样就可以保证同时到达最后一个节点了。由于两个链表从第一个公共节点开始到链表的尾节点部分都是重合的，因此，它们肯定也同时到达第一个公共节点。在遍历中，第一个相同的节点就是第一个公共的节点。

最后我们的方案是：先分别变量两个链表得到它们的长度，并求出两个长度之差x。在长链表上先遍历x次之后，再同步变量第二个链表，直到找到相同的节点或一直到链表结束。

该算法的时间复杂度是O(Length(head1)+Length(head2))。

完整代码如下：

#include <iostream>

#include <assert.h>

struct ListNode

{

int m_nKey;

ListNode* m_pNext;

};

void InitList(ListNode** head)

{

*head = (ListNode*)malloc(sizeof(ListNode));

(*head)->m_pNext = NULL;

}

void InsertList(ListNode* head, int data)

{

assert(head != NULL);

ListNode* pNewNode = (ListNode*)malloc(sizeof(ListNode));

pNewNode->m_nKey = data;

pNewNode->m_pNext = head->m_pNext;

head->m_pNext = pNewNode;

}

bool IsListIntercource(ListNode* pHead1, ListNode* pHead2)

{

if(pHead1 == NULL || pHead2 == NULL)

return false;

ListNode* pNode = pHead1;

while(pNode->m_pNext != NULL)

{

if(pNode->m_pNext->m_pNext == NULL)

{

pNode = pNode->m_pNext;

break;

}

pNode = pNode->m_pNext;

}

if((pHead2->m_pNext == NULL) && (pNode == pHead2))

return true;

while(pHead2->m_pNext != NULL)

{

if(pHead2->m_pNext->m_pNext == NULL)

{

if(pNode == pHead2->m_pNext)

return true;

else

return false;

}

pHead2 = pHead2->m_pNext;

}

}

int ListLength(ListNode* pHead)

{

int nLength = 0;

ListNode* pNode = pHead;

while(pNode->m_pNext != NULL)

{

++nLength;

pNode = pNode->m_pNext;

}

return nLength;

}

//核心算法，获得第一个相交的节点

ListNode* FindFirstCommonNode(ListNode* pHead1, ListNode* pHead2)

{

ListNode* pListHeadLong = NULL;

ListNode* pListHeadShort = NULL;

int nLen1 = ListLength(pHead1);

int nLen2 = ListLength(pHead2);

int nDiff = nLen1 - nLen2;

if(nDiff >= 0)

{

pListHeadLong = pHead1;

pListHeadShort = pHead2;

}

else

{

pListHeadLong = pHead2;

pListHeadShort = pHead1;

nDiff = -(nDiff);

}

//长链表先遍历nDiff个节点

for(int i=0; i<nDiff; i++)

pListHeadLong = pListHeadLong->m_pNext;

//接着在两个链表上同时遍历

while((pListHeadLong != NULL) &&

(pListHeadShort != NULL) &&

(pListHeadLong != pListHeadShort))

{

pListHeadLong = pListHeadLong->m_pNext;

pListHeadShort = pListHeadShort->m_pNext;

}

//返回第一个相交的节点

ListNode* pFirstCommonNode = NULL;

if(pListHeadLong == pListHeadShort)

pFirstCommonNode = pListHeadLong;

return pFirstCommonNode;

}

int main()

{

ListNode* pListHead1 = NULL;

ListNode* pListHead2 = NULL;

InitList(&pListHead1);

InitList(&pListHead2);

//建立两个链表

for(int i=9; i>=0; i--)

{

InsertList(pListHead1, i);

InsertList(pListHead2, i);

}

//新建一个节点

ListNode* pListNode = (ListNode*)malloc(sizeof(ListNode));

pListNode->m_nKey = 200;

pListNode->m_pNext = NULL;

ListNode* pTemp = pListHead1;

while(pTemp->m_pNext != NULL)

{

pTemp = pTemp->m_pNext;

}

pTemp->m_pNext = pListNode; //将新节点接在链表后面

pTemp = pListHead2;

while(pTemp->m_pNext != NULL)

{

pTemp = pTemp->m_pNext;

}

pTemp->m_pNext = pListNode; //将新节点接在链表后面

ListNode* pCommon = FindFirstCommonNode(pListHead1, pListHead2);

std::cout<<"第一个相交的节点值是："<<pCommon->m_nKey<<std::endl;

system("pause");

return 0;

}

iteye_6233
关注
C/C++ 两个链表的相交点算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-27 7492
两个链表的相交点算法是用来找出两个链表的第一个公共节点的方法，即两个链表在某个节点处开始重合。一种常见的解法是通过遍历两个链表来找到公共节点。另一种解法是通过计算链表的长度差来找到公共节点。
链表面试题之链表相交问题
微风
06-26 3563
如果你放弃那便没有人可以救得了你了，反而如果你坚持下去或许会有不一样的收获
leetcode.面试题 02.07. 链表相交
eilot_c的博客
07-06 221
面试题 02.07. 链表相交 给定两个（单向）链表，判定它们是否相交并返回交点。请注意相交的定义基于节点的引用，而不是基于节点的值。换句话说，如果一个链表的第k个节点与另一个链表的第j个节点是同一节点（引用完全相同），则这两个链表相交。 示例 1： 输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出：Reference of the node with value = 8
链表相交问题详解
yyykule的博客
05-25 863
但是A链表和B链表的长度不相等，我们怎么才能让curA指向a1的同时cueB指向b2呢？
算法之链表篇---相交链表
qq_44392499的博客
03-14 349
链接：https://leetcode.cn/problems/intersection-of-two-linked-lists/description/?其实看到这题我最先想到的做法，就是在链表中维护一个计数器，然后遍历两个链表，当便利到某个节点计数器 + 1 等于2时，就进行返回；两链表相交，节点从是否相交来分类，其实就是两种一种是有共同节点，一种是没有共同节点；指针B遍历完链表2后遍历链表1，两指针最后结果都为null。设链表1长度为a，链表2长度为b，链表相交长度为c。时间复杂度 ：O(n)
（十六）两个链表相交问题
蹦跶跶
12-19 927
两个链表相交问题 【题目】给定两个单链表，这两个单链表可能有环，也可能无环。其中头结点分别为head1、head2。实现一个函数，如果两个链表相交，请返回相交的第一个结点；如果不相交返回NULL； 【要求】如果两个链表长度之和为N，时间复杂度要求为O(N)，额外空间复杂度为O(1) 【解题思路】 第一步：判断两个链表是否有环，有环返回入环结点，无环返回NULL 判断链表是否有环 第二步：分情况讨论两个链表相交情况 （1）如果两个链表均无环，两个链表相交，那么从相交的部分开始都相等 ，结尾处也一定相
算法-链表：探索相交链表的奥秘
master_chenchen的博客
07-06 535
相交链表是指两个或多个链表共享一部分节点的现象。在C++中，链表由一系列节点构成，每个节点包含数据和指向下一个节点的指针。当两个链表的某部分节点重叠时，便形成了相交链表。这一特性在数据结构的分析和设计中显得尤为重要，尤其是在处理复杂的数据关系和优化数据查询效率方面。
java数据结构与算法之链表相交问题
wenpan的博客
05-11 440
两个单向链表相交问题 问题描述： 有两个单向链表他们可能相交，也可能不相交。若相交则返回相交的节点，若不相交则返回null。 两个单向链表相交，有且仅有三种情况。 链表相交的问题算是链表问题中最难的问题之一了！！！！ 一、逐一分析三种情况 【情况一】、两个无环链表 方法一、通过hash表来做 实现流程： 先从头到尾遍历一条链表，在遍历的同时将节点放入到hash表中 然后将第二条链表从头到尾开始遍历，遍历的同时首先查看hash表中有没有该节点 如果有则证明在第一条链表中已经将该节点加入过了，说明该节点
两链表相交问题
linchonghui888的博客
04-11 1975
两单向链表相交问题 一、问题分析 （1）两个链表相交，那么两个链表中的节点一定有相同地址。 （2）两个链表相交，那么两个链表从相交节点开始到尾节点一定都是相同的节点。 （问：为什么？ 答：因为每一个节点最多只能有一个下一节点，因此在相交节点之后，链表不可能再分为两个链表） 二、问题解法 根据两个链表是否存在环来分类讨论 1、无环 无环的情况有两种比较快速的解决方式，这两种方...
判断链表是否相交的几种算法1
08-03
本篇文章讨论了四种判断两个单链表是否相交的算法，这些算法主要应用于解决《编程之美》中的相关问题。 **解法一**是最直观的方法，称为“两两遍历法”。它通过分别遍历两个链表h1和h2，寻找h1中的节点是否出现在h2...
c语言链表的基本操作之相交链表实现.zip
03-28
6. **链表相交**：现在我们聚焦于相交链表的实现。相交链表是指两个链表在某点之后有共同的节点。一个简单的方法是先分别遍历两个链表，找出它们的长度，然后从较长链表的尾部开始，逐个节点与较短链表比较，直到...
基于Java实现的单链表基本操作之链表相交.zip
04-26
单链表是数据结构中的一种基础类型，它由...在处理链表相交的问题时，关键在于计算链表的长度并同步遍历它们，确保较短的链表在结束时与较长链表的某点相遇。这些基础知识对于理解和应用更复杂的数据结构算法至关重要。
顺序表和链表
yonpiguxiao的博客
09-18 187
int* data;} vector;区分程序内部信息和内存内部信息:我们应通过程序内部信息来操控内存内部信息;int data;}Node;
代码随想录算法训练营Day7
lynyzy的博客
09-18 502
双指针
代码随想录Day15 动态规划--4
m0_73740071的博客
09-17 332
通用的解法都是动态规划 暴力或者贪心都只适用于个别的场景对于股票问题最重要的是要确定每一天有多少个状态分清状态代码就很清晰。
CF 969 Div2
最新发布
hungry1234的博客
09-20 437
题意：给定区间lr，每次删除三个数abc，要求这三个数字两两互质，求最多删除几次题解：每次删除连续的三个数，要求第一个数是奇数即可。
LeetCode 459.重复的子字符串
weixin_50878507的博客
09-20 353
给定一个非空的字符串s，检查是否可以通过由它的一个子串重复多次构成。
【leetcode】堆习题
票票的博客
09-18 392
堆习题
LeetCode链表算法系列：两两交换节点，删除指定位置，链表相交与环形链表
链表相交：题目可能涉及判断两个链表是否有交点，这通常需要遍历和记忆节点，或者使用哈希表来辅助查找。解题时需要灵活运用链表特性，比如将两个链表的起点和终点分别存储起来，然后比较它们是否重合。 4. 142. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值