链表常见算法题四：链表相交及成环问题返回两个链表相交节点判断链表是否成环返回链表的入环节点

最新推荐文章于 2024-03-05 08:49:22 发布

野蛮生长的小VV

最新推荐文章于 2024-03-05 08:49:22 发布

阅读量268

点赞数

分类专栏：数据结构文章标签：链表链表成环返回节点

本文链接：https://blog.csdn.net/weixin_42572273/article/details/100943157

版权

数据结构专栏收录该内容

18 篇文章 0 订阅

订阅专栏

题目描述：编写一个程序，找到两个单链表相交的起始节点。

如下面的两个链表：
在这里插入图片描述
在节点 c1 开始相交。

示例 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
输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：
在这里插入图片描述
输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Reference of the node with value = 2

输入解释：相交节点的值为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：
在这里插入图片描述
输入：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。

注意：
如果两个链表没有交点，返回 null.
在返回结果后，两个链表仍须保持原有的结构。
可假定整个链表结构中没有循环。
程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。
来源：力扣（LeetCode）

解题思路：

我们不确定两个链表的交点，只有先遍历出两个链表的长度，当两个链表的长度已知时，我们可以采用右对齐，就是将遍历链表的两个指针从距末尾相同位置开始向前遍历，然后每次判断两指针的指向是否相等，相等就说明相交，并相等处为交点；否则，向前遍历，直到两指针均走到链表末尾还没有相遇，说明链表不相交！

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    if(headA==NULL||headB==NULL)
    {
        return NULL;
    }
    int sizeA=0;
    int sizeB=0;
    struct ListNode*curA=headA;
    struct ListNode*curB=headB;
    while(curA!=NULL||curB!=NULL)
    {
        if(curA!=NULL)
        {
            sizeA++;
            curA=curA->next;
        }
        if(curB!=NULL)
        {
            sizeB++;
            curB=curB->next;
        }
    }
    curA=headA;
    curB=headB;
    if(sizeA>sizeB)//当A链表长度大于B链表长度
    {
        while(sizeA>sizeB)
        {
            curA=curA->next;
            sizeA--;
        }
    }
    else
    {
        while(sizeA<sizeB)
        {
            curB=curB->next;
            sizeB--;
        }        
    }
    //此时curA和curB距链表尾部的距离相同
    while(curA!=NULL&&curB!=NULL)
    {
        if(curA==curB)
        {
            return curA;
        } 
        curA=curA->next;
        curB=curB->next;
    }
    return NULL;
}

题目描述：给定一个链表，判断链表中是否有环。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：true
在这里插入图片描述
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：true
在这里插入图片描述
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：false
在这里插入图片描述
解释：链表中没有环。
来源：力扣（LeetCode）

解题思路：
我在常见链表常见算法题三中使用了快慢指针法，这道题同样采用快慢指针法，链表成环，快慢指针会相遇，（可以想象成跑道，一人二倍速，一人原速，很像高中物理的追击相遇问题，两人势必会在跑道上相遇，不过二倍速的人比原速的多跑一圈的距离。）
快指针二倍速遍历，慢指针一步步向前遍历，
当快指针和慢指针指向同一节点时，说明快指针已经经过一圈追到慢指针；
当快指针遇到NULL（链表尾部）时，说明不成环，直接返回

代码实现：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
bool hasCycle(struct ListNode *head) {
    if(head==NULL)
    {
        return false;
    }
    struct ListNode*fast=head;
    struct ListNode*low=head;
    while(fast->next!=NULL&&fast->next->next!=NULL)
    {
        low=low->next;
        fast=fast->next->next;
        if(low==fast)//满足条件说明快慢指针相遇，有环
        {
            return true;
        }
    }
    return false;//退出while循环时说明链表遍历完，fast遇到NULL,则不成环
}

题目描述：给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改给定的链表。

示例 1：
在这里插入图片描述
输入：head = [3,2,0,-4], pos = 1
输出：tail connects to node index 1
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：
在这里插入图片描述
输入：head = [1,2], pos = 0
输出：tail connects to node index 0
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：
在这里插入图片描述
输入：head = [1], pos = -1
输出：no cycle
解释：链表中没有环。

进阶：
你是否可以不用额外空间解决此题？

来源：力扣（LeetCode）
代码实现：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *detectCycle(struct ListNode *head) {
    if(head==NULL)
    {
        return NULL;
    }
    struct ListNode *fast=head;
    struct ListNode *low=head;
    while(fast!=NULL&&fast->next!=NULL)
    {
        low=low->next;
        fast=fast->next->next;
        if(low==fast)
        {
            break;
        }
    }
    if(fast==NULL||fast->next==NULL)
    {
        return NULL;//不是环形，返回
    }
    low=head;//low从头开始，fast此时和low均和入环节点距离相同
    while(low!=fast)
    {
        low=low->next;
        fast=fast->next;
    }
    return low;
}