前言:本篇博客将讲解三个OJ题,前两个作为铺垫,最后完成环形链表的节点的寻找
文章目录
- 一、160. 相交链表
- 二、141. 环形链表
- 三、142. 环形链表II
一、160. 相交链表
题目链接:LeetCode—相交链表
题目描述:
给你两个单链表的头节点 headA 和 headB ,请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点,返回 null 。
图示两个链表在节点 c1 开始相交:
注意,函数返回结果后,链表必须 保持其原始结构 。
评测系统将根据这些输入创建链式数据结构,并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点,那么你的解决方案将被 视作正确答案 。
示例1:
输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出:Intersected at ‘8’
解释:相交节点的值为 8 (注意,如果两个链表相交则不能为 0)。
示例2:
输入:intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出:null
解释:从各自的表头开始算起,链表 A 为 [2,6,4],链表 B 为 [1,5]。
由于这两个链表不相交,所以 intersectVal 必须为 0,而 skipA 和 skipB 可以是任意值。
这两个链表不相交,因此返回 null 。
题目解析:
- 遍历链表计算长度: 初始化两个指针curA和curB分别指向链表headA和headB的头节点,然后遍历链表,分别计算链表的长度lenA和lenB,来到尾节点时比较是否一致,一致说明链表相交;否则,不相交,即可返回NULL。
- 对齐起点:如果尾节点相同,计算两个链表长度的差值n,然后选取较长链表的头节点为longList,较短链表的头节点为shortList。然后,将longList指针向后移动n个位置,使得两个链表剩余长度相等。
- 寻找交点: 同时遍历longList和shortList,找到它们第一个相同的节点,即为交点。
代码实现:
typedef struct ListNode ListNode;
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
ListNode* curA = headA, *curB = headB;
// 初始化链表headA和headB的长度分别为1,原因是curA和curB初始化就指向头
int lenA = 1, lenB = 1;
// 计算链表headA的长度
while (curA->next) {
lenA++;
curA = curA->next;
}
// 计算链表headB的长度
while (curB->next) {
lenB++;
curB = curB->next;
}
// 如果链表headA和headB的尾节点不相同,说明它们没有交点,返回NULL
if (curA != curB) {
return NULL;
}
//abs 函数是 C 语言标准库(<stdlib.h> 头文件)中的一个函数,用于返回整数的绝对值
int n = abs(lenA - lenB);
// 初始化指针longList和shortList,分别指向较长和较短的链表头部
ListNode* longList = headA, *shortList = headB;
// 如果链表headA较短,调整longList和shortList的指向
if (lenA < lenB) {
longList = headB;
shortList = headA;
}
// 将较长链表指针向后移动,使两个链表剩余长度相等
while (n--) {
longList = longList->next;
}
// 同时移动长链表和短链表指针,直到找到交点
while (longList != shortList) {
longList = longList->next;
shortList = shortList->next;
}
// 返回交点(如果存在)
return longList;
}
二、141. 环形链表
题目链接:LeetCode—环形链表
题目描述:
给你一个链表的头节点 head ,判断链表中是否有环。
如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。
注意:pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。
如果链表中存在环 ,则返回 true 。 否则,返回 false 。
示例 1:
输入:head = [3,2,0,-4], pos = 1
输出:true
解释:链表中有一个环,其尾部连接到第二个节点。
示例 2:
输入:head = [1,2], pos = 0
输出:true
解释:链表中有一个环,其尾部连接到第一个节点。
示例 3:
输入:head = [1], pos = -1
输出:false
解释:链表中没有环。
题目解析:
这是经典的快慢指针算法用于检测链表中是否存在环。算法的核心思想是使用两个指针,一个移动速度较慢(每次移动一步),另一个移动速度较快(每次移动两步)。如果链表中存在环,快指针最终会追上慢指针,导致它们相遇。
在遍历过程中,如果快指针能够追上慢指针,就说明存在环。如果没有相遇,而是快指针达到链表的末尾(为NULL),则链表是无环的。
这种算法的时间复杂度为 O(N),其中 N 是链表的长度。这是因为在最坏情况下,快指针将遍历整个链表一次。
代码实现:
typedef struct ListNode ListNode;
bool hasCycle(struct ListNode *head) {
// 初始化两个指针,slow每次移动一步,fast每次移动两步
ListNode* slow = head;
ListNode* fast = head;
// 遍历链表,直到fast为NULL或fast的下一个节点为NULL
while (fast != NULL && fast->next != NULL) {
// slow前进一步
slow = slow->next;
// fast前进两步
fast = fast->next->next;
// 如果存在环,slow和fast会在某个时刻相遇
if (slow == fast) {
// 存在环,返回true
return true;
}
}
// 遍历完成,没有相遇,说明链表无环
return false;
}
思考问题:快慢指针的速度有要求吗,会不会存在快指针和慢指针不相遇的情况。
首先说结论,只要有速度差,都可以相遇。
想象一下,快慢指针相遇时,它们在环内,且快指针比慢指针多走了n个环,C是环的大小,我们令快指针的速度为a,慢指针的速度为b。
假设快慢指针走k步,它们相遇。又因为相遇时,快指针比慢指针多走了n个环。我们可以得到 ( a − b ) k = n C (a-b)k = nC (a−b)k=nC。
我们从题中得知a-b和C,k和n是未知数。易知一定存在整数k和整数n使得等式成立。得出结论,快慢指针一定能在环内相遇。
三、142. 环形链表II
题目链接:LeetCode—环形链表II
经过前两题的铺垫,这题的思路更容易打开了
题目描述:
给定一个链表的头节点 head ,返回链表开始入环的第一个节点。 如果链表无环,则返回 null。
如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。如果 pos 是 -1,则在该链表中没有环。
注意:pos 不作为参数进行传递,仅仅是为了标识链表的实际情况。
不允许修改 链表。
示例 1:
输入:head = [3,2,0,-4], pos = 1
输出:返回索引为 1 的链表节点
解释:链表中有一个环,其尾部连接到第二个节点。
示例 3:
输入:head = [1], pos = -1
输出:返回 null
解释:链表中没有环。
题目解析:
判断是否有环: 快指针速度设为2,慢指针设为1(为了找入环节点必须这样设置,下面会阐述原因),无环直接返回NULL。
找入环节点: 快指针速度设为2,慢指针设为1的原因在这,想象一下,在极端情况下,快慢指针同时从入环节点出发(可以看作快指针与慢指针相距一个环的距离)。这种情况下,慢指针走了半环,快指针走了一个环;接着慢指针走完剩下半个环来到入环点,这时快指针又走了一个环来到入环点。快慢指针在入环节点相遇了。
在实际情况下,快指针一定先入环,接着慢指针从头节点到达入环节点,这时快慢指针的距离一定小于或等于环。那么可想而知,它们相遇时,慢指针最多走完一次环,快指针在从慢指针入环到它们相遇时也最多走完两次环。 我们设相遇时距离入环节点为X,C时环的大小(X<=C)。
相遇时有等式 2 ( L + X ) = L + n ∗ C + X 2(L+X)=L+n*C+X 2(L+X)=L+n∗C+X (快指针的路程=L+从头节点到相遇时走了n次环+X,慢指针的路程=L+X)。化简得 L = ( n − 1 ) ∗ X + C − X L=(n-1)*X+C-X L=(n−1)∗X+C−X,从公式中我们可以看出,当我们走完L(到达入环节点),等于从距离入环节点的X处开始走,可以走(n-1)次环加上C-X(到达入环节点)。
因此,用两个相同速度的指针,一个从头节点开始走,另一个从相遇点开始走,最终会在入环节点相遇。
代码实现:
typedef struct ListNode ListNode;
struct ListNode *detectCycle(struct ListNode *head) {
// 初始化两个指针,slow每次移动一步,fast每次移动两步
ListNode* slow = head;
ListNode* fast = head;
// 遍历链表,直到fast为NULL或fast的下一个节点为NULL
while (fast && fast->next) {
// slow前进一步
slow = slow->next;
// fast前进两步
fast = fast->next->next;
// 如果存在环,slow和fast会在某个时刻相遇
if (slow == fast) {
// 相遇点保存在meet中,从链表头开始和meet同时移动,直到再次相遇,即为环的起点
ListNode* meet = slow;
while (head != meet) {
head = head->next;
meet = meet->next;
}
// 返回环的起点
return meet;
}
}
// 遍历完成,没有相遇,说明链表无环
return NULL;
}
如果你喜欢这篇文章,点赞👍+评论+关注⭐️哦!
欢迎大家提出疑问,以及不同的见解。