快慢指针判断单链表是否有环证明问题。

通过快慢指针方法,详细介绍了如何判断单链表是否存在环、计算环长、找到环的入口点以及链表总长度。讨论了不同步长下快慢指针的相遇情况。

1.判断单链表是否有环:
使用快慢指针fast和slow,fast每次走两步,slow每次走一步,如果有环,肯定会相遇,如果没有,则指针fast遇到NULL退出。追及相遇问题。
2.求有环单链表的环长
在环上相遇后,记录第一次相遇点为Pos,之后指针slow继续每次走1步,fast每次走2步。在下次相遇的时候fast比slow正好又多走了一圈,也就是多走的距离等于环长。
设从第一次相遇到第二次相遇,设slow走了len步,则fast走了2*len步,相遇时多走了一圈:

环长=2*len-len

3.求有环单链表的环连接点位置

也就是A的位置是头节点,B表示环入口处,C表示快慢指针第一次相遇处。 在C处相遇时,设慢指针跑了N步,也就是从A开始N步后会到达C。

快指针比慢指针走的快一倍,也就是走了2*N步。那么慢指针从C处再跑N步还会回到C处。 既然都会回到C处,那么必然会在B点第一次相遇。
所以我们在入口处再设一指针(用之前快指针即可),与慢指针用1步长同时前进,第一次相遇处就是环入口处

在这里插入图片描述

第一次碰撞点Pos到连接点Join的距离=头指针到连接点Join的距离,因此,分别从第一次碰撞点Pos、头指针head开始走,相遇的那个点就是连接点。在环上相遇后,记录第一次相遇点为Pos,连接点为Join,假设头结点到连接点的长度为LenA,连接点到第一次相遇点的长度为x,环长为R。

第一次相遇时,slow走的长度 S = LenA + x;
    第一次相遇时,fast走的长度 2S = LenA + nR + x;
    所以可以知道,LenA

<think>我们要判断一个单链表是否,可以使用快慢指针(Floyd's cycle-finding algorithm)方法。 快慢指针:定义两个指针,一个每次移动两步(快指针),一个每次移动一步(慢指针)。如果链表中存在,那么快指针最终会追上慢指针(即两个指针相遇);如果不存在,那么快指针会先到达链表的尾部(None)。 步骤: 1. 初始化:快指针(fast)和慢指针(slow)都指向头结点。 2. 移动指针:在循中,慢指针每次移动一步,快指针每次移动两步。 3. 检查相遇:如果快指针和慢指针相遇,则链表有。 4. 检查结束:如果快指针到达链表尾部(即遇到None),则链表无。 注意:在移动快指针时,需要判断指针的下一个节点是否为None,因为快指针每次移动两步,所以需要确保fast和fast.next都不为空,否则在移动两步时会出错。 代码实现:</think>### 判断单链表是否的解决方案 判断单链表是否是链表操作中的经典问题,通常使用**快慢指针法**(Floyd's Cycle Finding Algorithm)来解决。以下是详细的实现方案: #### 方法:快慢指针法(Floyd 判圈算法) ```python class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next def has_cycle(head: ListNode) -> bool: """ 判断单链表是否 :param head: 链表头节点 :return: 存在返回True,否则返回False """ # 边界情况:空链表或单节点链表 if not head or not head.next: return False slow = head # 慢指针,每次移动一步 fast = head.next # 快指针,每次移动两步 while slow != fast: # 快指针到达链表尾部(无) if not fast or not fast.next: return False slow = slow.next # 慢指针移动一步 fast = fast.next.next # 快指针移动两步 # 快慢指针相遇(有) return True # 测试用例 if __name__ == "__main__": # 创建有链表:1->2->3->4->5->2(形成) node1 = ListNode(1) node2 = ListNode(2) node3 = ListNode(3) node4 = ListNode(4) node5 = ListNode(5) node1.next = node2 node2.next = node3 node3.next = node4 node4.next = node5 node5.next = node2 # 形成 print(has_cycle(node1)) # 输出: True # 创建无链表:1->2->3->4->5 node5.next = None # 断开 print(has_cycle(node1)) # 输出: False # 单个节点无 single_node = ListNode(1) print(has_cycle(single_node)) # 输出: False # 单个节点自 single_node.next = single_node print(has_cycle(single_node)) # 输出: True ``` ### 代码解释 #### 核心算法原理 1. **快慢指针**: - 慢指针(`slow`):每次移动一步 - 快指针(`fast`):每次移动两步 - 如果存在,快指针最终会追上慢指针(相遇) - 如果无,快指针会先到达链表尾部(`None`) 2. **数学证明**: - 设外长度为 `L`,长度为 `C` - 当慢指针进入时(移动 `L` 步),快指针已移动 `2L` 步(位置 `2L mod C`) - 快指针每次比慢指针多走一步,最多需要 `C` 步追上慢指针 - 总时间复杂度为 `O(L + C)` ≈ `O(n)` #### 关键实现细节 1. **初始条件**: ```python slow = head fast = head.next # 避免第一次循就相遇 ``` - 这样初始化可以处理头节点自的情况 2. **循条件**: ```python while slow != fast: if not fast or not fast.next: return False # 移动指针... ``` - 检查 `fast.next` 避免访问空指针的 `next` 属性 3. **边界处理**: - 空链表:`if not head` - 单节点链表:`if not head.next` - 自链表:`node.next = node` #### 复杂度分析 - **时间复杂度**:O(n) - 最坏情况:无时遍历整个链表(n 个节点) - 最好情况:有时最多遍历 2n 次 - **空间复杂度**:O(1) - 仅使用两个指针,常数级空间 ### 替代方法:哈希表法 ```python def has_cycle_hash(head: ListNode) -> bool: visited = set() current = head while current: if current in visited: return True visited.add(current) current = current.next return False ``` - **原理**:记录访问过的节点,遇到重复节点即有 - **优点**:逻辑简单 - **缺点**:空间复杂度 O(n),不适用于大链表
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值