如何判断一个单链表是有环的?

本文介绍了一种高效的单链表环检测算法,利用快慢指针技术在O(n)的时间复杂度内判断单链表是否存在环。通过一个快速指针每次移动两步和一个慢速指针每次移动一步的方式,如果两者相遇则表明存在环。
一、如何判断一个单链表是有环的?(注意不能用标志位,最多只能用两个额外指针)
struct node { char val; node* next;}
bool check(const node* head) {} //return false :
无环;true:有环
一种On)的办法就是(搞两个指针,一个每次递增一步,一个每次递增两步,如果有环的话两者必然重合,反之亦然):
bool check(const node* head)
{
if(head==NULL)
return false;
node *low=head, *fast=head->next;
while(fast!=NULL && fast->next!=NULL)
{
low=low->next;
fast=fast->next->next;
if(low==fast)
return true;
}
return false;
}
<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、付费专栏及课程。

余额充值