0
点赞
收藏
分享

微信扫一扫

单链表中的环涉及到的6个相关问题

关于单链表中的环,一般涉及到以下问题:

1.给一个单链表,判断其中是否有环的存在;

       使用快慢指针,每次快指针比慢指针多走一步,即慢指针每次走一步,快指针每次走两步,直到快指针又追到慢指针,说明存在环,并且快指针一定会在慢指针走完第一圈之前和它相遇。时间复杂度为线性。

 单链表中的环涉及到的6个相关问题_时间复杂度

 

 单链表中的环涉及到的6个相关问题_链表_02

单链表中的环涉及到的6个相关问题_链表_03

 

 

 单链表中的环涉及到的6个相关问题_时间复杂度_04

 

 单链表中的环涉及到的6个相关问题_链表_05

 

 单链表中的环涉及到的6个相关问题_链表_06

 

 

2.如果存在环,找出环的入口点;

       如图中所示,设链起点到环入口点间的距离为x,环入口点到问题1中fast与slow重合点的距离为y,又设在fast与slow重合时fast已绕环n周(n>0),且此时slow移动总长度为s,则fast移动总长度为2s,环的长度为r。则

       s + nr = 2s,n>0      ①

       s = x + y               ②

      由①式得  s = nr               

      代入②式得

      nr = x + y

      x = nr - y                ③

      现让一指针p1从链表起点处开始遍历,指针p2从相遇点处开始遍历,且p1和p2移动步长均为1。则当p1移动x步即到达环的入口点,由③式可知,此时p2也已移动x步即nr - y步。由于p2是从相遇点处开始移动,故p2移动nr步是移回到了相遇点处,再退y步则是到了环的入口点。也即,当p1移动x步第一次到达环的入口点时,p2也恰好到达了该入口点。


3.如果存在环,求出环上节点的个数(环的长度);

       fast和slow第一次相遇后,再继续,第二次相遇时,fast正好多走了一个环的长度。

 

4.如果存在环,求出链表的长度;

第2题中已经求出了起点到入口点的距离,第3题中已经求出了环的长度,两者相加即为链表长度。


5.如果存在环,求出环上距离任意一个节点最远的点(对面节点);

       对于换上任意的一个点ptr0, 我们要找到它的”对面点“,可以这样思考:同样使用上面的快慢指针的方法,让slow和fast都指向ptr0,每一步都执行与上面相同的操作(slow每次跳一步,fast每次跳两步),当fast = ptr0或者fast = prt0->next的时候slow所指向的节点就是ptr0的”对面节点“。

       为什么是这样呢?我们可以这样分析:

 单链表中的环涉及到的6个相关问题_双指针_07

如上图,我们想像一下,把环从ptr0处展开,展开后可以是无限长的(如上在6后重复前面的内容)如上图。现在问题就简单了,由于slow移动的距离永远是fast的一半,因此当fast遍历完整个环长度r个节点的时候slow正好遍历了r/2个节点,也就是说,此时正好指向距离ptr0最远的点。


6.(扩展)如何判断两个无环链表是否相交;如果相交,求出第一个相交的节点。

方法一:暴力法

单链表中的环涉及到的6个相关问题_链表_08

 

方法二:哈希表

单链表中的环涉及到的6个相关问题_双指针_09

 

方法三:双指针之一

(1) 遍历链表A, B,计算出他们分别的长度lenA, lenB。

(2) 链表长的指针向后移动到俩个链表长度差的位置。

(3) 之后一一进行比较。

复杂度分析

时间复杂度:O(lenA + lenB)

空间复杂度:O(1)

1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
12 if(headA == NULL || headB == NULL)
13 return NULL;
14
15 int lenA = 0, lenB = 0;
16 ListNode *p;
17 p = headA;
18 while(p != NULL) {
19 lenA++; //计算链表A的长度
20 p = p->next;
21 }
22
23 p = headB;
24 while(p != NULL) {
25 lenB++; //计算链表B的长度
26 p = p->next;
27 }
28
29 ListNode *pa = headA, *pb = headB;
30 if(lenA >= lenB) {
31 int diff = lenA-lenB;
32 for(int i = 0; i < diff; ++i) {
33 pa = pa->next; //A先走diff步
34 }
35
36 } else {
37 int diff = lenB-lenA;
38 for(int i = 0; i < diff; ++i) {
39 pb = pb->next; //B先走diff步
40 }
41 }
42
43 while(pa != pb) { //之后一起走
44 pa = pa->next;
45 pb = pb->next;
46 }
47
48 return pa;
49 }
50 };

 

方法四:双指针之二(推荐)

设链表A的不同部分长度为n(不包括交点), 链表B不同部分长度为m (不包括交点), 两链表相同部分长度为t(包括交点);

根据加法结合律,有:(n + t) + m = (m + t) + n,即:lenA + m = lenB + n。

则:我们使用两个指针pa,pb分别指向两个链表的头结点 headA,headB,然后同时分别逐结点遍历,当 pa 到达链表A的末尾时,重新定位到链表B的头结点headB;当 pa 到达链表B的末尾时,重新定位到链表A的头结点headA。

这样,当它们相遇时,所指向的结点就是第一个公共结点。如下图C1:

单链表中的环涉及到的6个相关问题_双指针_10

 

 

对于两链表无交点的情况,如果令pa -> next == NULL时将其重新定位到headB,pb->next == NULL时将其重新定位到headA,将会死循环,两者永远不会相遇。如下图,

单链表中的环涉及到的6个相关问题_双指针_11

 

 

为了方便编程,使得其与上述情况一样,可以将NULL视为它们的交点,此时编程的时候就要令,当 pa == NULL时,将其重新定位到headB,而不是pa -> next == NULL时将其重新定位到headB;pb同理。

最后pa和pb将在NULL处相遇。

单链表中的环涉及到的6个相关问题_时间复杂度_12

复杂度分析

时间复杂度:O(lenA + lenB)

空间复杂度:O(1)

1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
12 ListNode *pa = headA, *pb = headB;
13 while(pa != pb) {
14 //这里不能写if(pa->next == NULL),否则无法判定两链表无交点的情况
15 if(pa == NULL)
16 pa = headB;
17 else
18 pa = pa->next;
19
20 //这里不能写if(pb->next == NULL),否则无法判定两链表无交点的情况
21 if(pb == NULL)
22 pb = headA;
23 else
24 pb = pb->next;
25
26 }
27
28 return pa;
29 }
30 };

 

方法五:双指针之三

       对于问题6(扩展)如何判断两个无环链表是否相交,和7(扩展)如果相交,求出第一个相交的节点,其实就是做一个问题的转化:

假设有连个链表listA和listB,如果两个链表都无环,并且有交点,那么我们可以让其中一个链表(不妨设是listA)的为节点连接到其头部,这样在listB中就一定会出现一个环。因此我们将问题6和7分别转化成了问题1和2。

看看下图就会明白了:

 单链表中的环涉及到的6个相关问题_双指针_13

 

复杂度分析

时间复杂度:O(lenA + lenB)

空间复杂度:O(1)

1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
12 if(headA == NULL || headB == NULL)
13 return NULL;
14
15 ListNode *tailA = headA;
16 while(tailA->next != NULL) {
17 tailA = tailA->next;
18 }
19
20 tailA->next = headA; //令链表A循环
21
22 ListNode *fast, *slow;
23 if(headB->next == NULL) {
24 tailA->next = NULL; //恢复原链表的结构
25 return NULL;
26 } else {
27 slow = headB->next;
28 fast = headB->next->next;
29 }
30
31 while(fast != slow) {
32 //由于链表A已经成环,如果此时slow为NULL,可以说明链表A,B无交点
33 if(slow->next == NULL || fast->next == NULL || fast->next->next == NULL) {
34 tailA->next = NULL; //恢复原链表的结构
35 return NULL;
36 }
37
38 slow = slow->next;
39 fast = fast->next->next;
40 }
41
42 ListNode *pb = headB;
43 while(pb != slow) {
44 slow = slow->next;
45 pb = pb->next;
46 }
47
48 tailA->next = NULL; //恢复原链表的结构
49
50 return slow;
51 }
52 };

 

参考文章

判断链表中是否有环 ----- 有关单链表中环的问题

存在环的单链表寻找环的入口点

剑指 Offer 52. 两个链表的第一个公共节点

 


举报

相关推荐

0 条评论