已知两个长度为m和n的升序链表，将他们合并为长度为m+n的降序链表，最坏情况下时间复杂度怎样求

Posted 2023-04-18

已知两个长度为m和n的升序链表将他们合并为长度为m+n的降序链表，最坏情况下时间复杂度怎样求，合并时最坏情况下，长为n的链表中前n-1个都比长为m的链表中的第一元素小，而长为n的链表中最后一元素又比长为m的链表中所有元素大。这样比较元素的次数n+m,则时间复杂度为O(m+n) 参考技术A 两个升序表合并，两两比较表中的元素，每比较一次确定一个元素的位置（取较小的元素，头插法）。当一个链表比较结束后，将另一个链表的剩余元素插入即可。最坏的情况是两个链表中的元素一次比较，所以时间复杂度是O（max(m,n)） 参考技术B 设a<b，即a=min(m,n)/b=max(m,n)。
两个表都是升序，选择a长度的链表为结果表，a链表的第一个元素开始和b链表第一个元素比较，如果a0 < b0，则将a0插到b0前，然后a1和b0比较，以此类推；
最好情况是a全排在b前，时间复杂度为O(min(m,n))，最坏情况是有元素排在m后，时间复杂度为O(max(m,n)) 参考技术C 这里可能比较有争议的就是o（n+m）和o（max（m，n）），按我个人的理解只有以下两种情况，1：m或n其中一个趋于无穷，另一个为常数，复杂度为o（max（m，n））；2：m和n趋于相等，即2m或2n，按复杂度的计算方法来看，无论是2m还是2n，复杂度还是o（max（m，n）） 参考技术D 排序是双循环，最坏情况下的时间复杂度即为（m+n）的平方。

两个链表的第一个公共节点

已知有两个链表，他们可能相交于某一点，求出该点。

方法1.对于第一个链表，每访问一个节点，对该节点做标记。访问第二个链表，如果该元素已经访问，则第一个这样的元素就是所求点。

由于两个链表都访问了一遍，因此时间复杂度O(m+n),空间复杂度O(m)或O(n)

方法2.我们定义节点的距离为节点到链表开始所经过的节点数。如果两个链表长度相同，则相交节点其在两个链表上的距离一定相等。对于长度不同的两个链表，我们可以采用对齐的方式，使其向长度短的链表对齐。这样就可以应用上面的思路。具体算法如下：

 

[cpp] view plain copy

 

print?

1. struct node  
2. {  
3.     int v;  
4.     node *next;  
5. };  
6. /* 
7. 返回链表的长度 
8. 链表为空 返回0 
9. */  
10. size_t listLen(node * p)  
11. {  
12.     size_t num = 0;  
13.     while (p!=NULL)  
14.     {  
15.         num++;  
16.         p = p->next;  
17.     }  
18.     return num;  
19. }  
20. // 如果找到了 则返回指针 指向公共节点  
21. // 如果不存在 则返回空指针  
22. node * findFirstCommenNode(node * pheada, node * pheadb)  
23. {  
24.     size_t lenA = listLen(pheada);  
25.     size_t lenB = listLen(pheadb);  
26.   
27.     node * plistA = pheada;  
28.     node * plistB = pheadb;  
29.     //调整长度  
30.     //plistA 指向较长的一个  
31.     if (lenA < lenB)  
32.     {  
33.         plistB = pheada;  
34.         plistA = pheadb;  
35.         size_t t = lenA;  
36.         lenA = lenB;  
37.         lenB = t;  
38.     }  
39.     while(lenA > lenB)  
40.     {  
41.         plistA = plistA->next;  
42.         --lenA;  
43.     }  
44.     //一样长了  
45.     //寻找公共节点  
46.     while (plistA!=NULL && plistA != plistB)  
47.     {  
48.         plistA = plistA->next;  
49.         plistB = plistB->next;  
50.     }  
51.     return plistA;  
52. }  

struct node
{
	int v;
	node *next;
};
/*
返回链表的长度
链表为空 返回0
*/
size_t listLen(node * p)
{
	size_t num = 0;
	while (p!=NULL)
	{
		num++;
		p = p->next;
	}
	return num;
}
// 如果找到了 则返回指针 指向公共节点
// 如果不存在 则返回空指针
node * findFirstCommenNode(node * pheada, node * pheadb)
{
	size_t lenA = listLen(pheada);
	size_t lenB = listLen(pheadb);

	node * plistA = pheada;
	node * plistB = pheadb;
	//调整长度
	//plistA 指向较长的一个
	if (lenA < lenB)
	{
		plistB = pheada;
		plistA = pheadb;
		size_t t = lenA;
		lenA = lenB;
		lenB = t;
	}
	while(lenA > lenB)
	{
		plistA = plistA->next;
		--lenA;
	}
	//一样长了
	//寻找公共节点
	while (plistA!=NULL && plistA != plistB)
	{
		plistA = plistA->next;
		plistB = plistB->next;
	}
	return plistA;
}

 

算法的空间复杂度O(1)，时间复杂度O(m+n)，效果不错吧。

如果链表中有环会怎么样呢？

上面的算法会死循环的。在求解链表长度的时候就会死循环了。但是这样的问题该如何解决呢。

首先的解决访问带环链表的问题。如果访问带环链表访问解决了，那么使用方法一就可以解决原问题，但是能不用优化到算法二的空间复杂度呢。算法二的思路还是很可取的，这里可不可以继续使用呢？

我们定义链表的长度为链表中节点的个数，如果链表相交，应该还是具有算法二的性质。因此，修改求取链表长度的算法，使用算法二。具体算法如下：

 

[cpp] view plain copy

 

print?

1. // 如果找到了 则返回指针 指向公共节点  
2. // 如果不存在 则返回空指针  
3. // pheada 指向第一个链表的头  
4. // pheadb 指向第二个链表的头  
5. node * findFirstCommenNode(node * pheada, node * pheadb)  
6. {  
7.     size_t lenA = listLen(pheada);  
8.     size_t lenB = listLen(pheadb);  
9.   
10.     node * plistA = pheada;  
11.     node * plistB = pheadb;  
12.     //调整长度  
13.     //plistA 指向较长的一个  
14.     if (lenA < lenB)  
15.     {  
16.         plistB = pheada;  
17.         plistA = pheadb;  
18.         size_t t = lenA;  
19.         lenA = lenB;  
20.         lenB = t;  
21.     }  
22.     while(lenA > lenB)  
23.     {  
24.         plistA = plistA->next;  
25.         --lenA;  
26.     }  
27.     //一样长了  
28.     //寻找公共节点  
29.     while (lenA !=0 && plistA != plistB)  
30.     {  
31.         plistA = plistA->next;  
32.         plistB = plistB->next;  
33.         --lenA;//这里进行修改,免得进入环后死循环  
34.     }  
35.     return plistA;  
36. }