带环链表(由简单到深入)—C语言实现

一.判断该链表是否有环(简单):

1.题目

2.思路:

快慢指针 :慢指针每走一步,快指针走两步,两个指针的起始位置都在原链表的头节点。
果链表 带环,就一定会在环中相遇,否则快指针就先走到链表的末尾。

复制代码
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
bool hasCycle(struct ListNode *head) {
    struct ListNode* slow = head,*fast = head;
    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
        if(fast == slow)
        {
            return true;
        }
    }
    return false;
}

3.扩展问题:

(1) 为什么一定会相遇?有没有可能错过,永远追不上?

如果链表带环,那么两个指针最后都会进入环,快指针先进环,慢指针后进。

当慢指针刚进环时,最好的可能就是直接和快指针相遇,最差的情况下,两个指针的距离刚好就是换的长度。此时,两个指针每移动一次,之间的距离就缩小一步,不会出现每次刚好是套圈的情况。

因此:在慢指针走到一圈之前,快指针肯定能追上慢指针(相遇)。

(2) 快指针一次走3步,走四步,...n步,能追上吗?

简单分析一下快指针走三步的情况:

(3)上述是我们理论猜想出来的结果,但是实际真的存在永远追不上的情况吗?

分析:

重新总结:

二.环形链表2

1.题目

2.思路1:

我们对指针运动进行数学分析最终得到了头结点到入环节点的距离L与环形链表的关系。

分析代数式,我们得到启发:

两个指针:一个指针从链表的起始位置开始遍历链表,同时让另一个指针从判环时相遇点(meet)开始绕环运行,两个指针都是每次走一步,最终肯定会在入口节点的位置相遇。

注意:

(1)当慢指针进入环时,快指针可能已经在环中饶了x圈了,x至少为1。

因为:快指针先进环走到判环相遇点meet的位置,最后又在meet的位置于慢指针相遇。

(2)慢指针进入环后,快指针肯定会在慢指针走一圈之内追上慢指针。

因为:慢指针进入环后,快慢指针之间的距离最多就是环的长度,而两个指针在移动前,每次他们之间的距离都缩减一步,因此慢指针进入环后,快指针肯定会在慢指针走一圈之内追上慢指针。

3.参考代码

复制代码
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode* slow = head,*fast = head;
    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
        if(fast == slow)
        {
            struct ListNode* meet = fast;
            while(head != meet)//指针相交时的位置就是入环位置
            {
                head = head->next;
                meet = meet->next;
            }
            return meet;
        }
    }
    return NULL;
}

4.思路二

创建一个新指针newhead,指向meet的next指针,再将meet的next置为NULL。这样就变成了我们所熟悉的相交链表问题。 大家可以看我的这篇题解http://t.csdnimg.cn/edNbx

参考代码:

复制代码
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
//相交链表,如果相交返回相交节点,否则,返回NULL
 struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    int n1 = 1;
    int n2 = 1;
   struct ListNode* curA = headA;
   struct ListNode* curB = headB;
    while(curA->next)
    {
        curA = curA->next;
        ++n1;
    }
    while(curB->next)
    {
        curB = curB->next;
        ++n2;
    }
    if(curA != curB)
    {//尾节点不相等就不相交
        return NULL;
    }
    //长的先走差距步,再同时走,第一个相等的就是交点
    int num = abs(n1 - n2);
    struct ListNode* LongList = headA;
    struct ListNode* SortList = headB;
    if(n1 < n2)
    {
        LongList = headB;
        SortList = headA;
    }
    while(num--)
    {
        LongList = LongList->next;
    }
    while(LongList != SortList)
    {
        LongList = LongList->next;
        SortList = SortList->next;
    }
    return LongList;
}


struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode* slow = head,*fast = head;
    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
        if(fast == slow)
        {
            struct ListNode* meet = fast;
            struct ListNode* newhead = meet->next;
            meet->next = NULL;
            return getIntersectionNode(newhead,head);
        }
    }
    return NULL;
}
相关推荐
Fanxt_Ja2 天前
【LeetCode】算法详解#15 ---环形链表II
数据结构·算法·leetcode·链表
今后1232 天前
【数据结构】二叉树的概念
数据结构·二叉树
散1123 天前
01数据结构-01背包问题
数据结构
消失的旧时光-19433 天前
Kotlinx.serialization 使用讲解
android·数据结构·android jetpack
Gu_shiwww3 天前
数据结构8——双向链表
c语言·数据结构·python·链表·小白初步
苏小瀚3 天前
[数据结构] 排序
数据结构
_不会dp不改名_3 天前
leetcode_21 合并两个有序链表
算法·leetcode·链表
睡不醒的kun3 天前
leetcode算法刷题的第三十四天
数据结构·c++·算法·leetcode·职场和发展·贪心算法·动态规划
吃着火锅x唱着歌3 天前
LeetCode 978.最长湍流子数组
数据结构·算法·leetcode
Whisper_long3 天前
【数据结构】深入理解堆:概念、应用与实现
数据结构