判断一个单链表中是否有环

一、题目

判断一个单链表中是否存在环。


二、解法

设置两个工作指针slow和fast,初始值都指向群头节点,slow每次前进一步,fast每次前进两步,如果链表中存在环,则fast必定先进入环,而slow后进入环,两个指针必定相遇。(当然,fast遍历到NULL,则为无环链表)这样就可以判断两个链表是否相交了。

代码实现:

bool IsLoop(LinkList *list)
{
	Linkist *slow=new LinkList();
	Linkist *fast=new LinkList();
	slow=list,fast=list;
	while(fast && fast->next)
	{
		slow=slow->next;
		fast=fast->next->next;
		if(slow==fast)
			break;
}return !(fast == NULL||fast->next==NULL);}


三、拓展问题

寻找链表环的入口节点。

  解法:

当fast和slow相遇时,slow肯定没有走遍完链表,而fast已经在环内循环了n圈(n>=1)。假设slow走了s步,则fast走了2s步(fast步数还等于s加上在环上多走的n圈),设环长为r,则:

2s=s+nr;

s=nr;

设整个链表长L,环入口与相遇点距离为x,起点到环入口的距离为a。

则有:

a+x=s=nr;

a+x=(n-1)r+r=(n-1)r+L-a;

a=(n-1)r+(L-a-x);

(L-a-x)为相遇点到环入口点的距离,由此可知,从链表头到环入口点等于(n-1)循环内环+相遇点到环入口点的距离。

于是我们从链表头、与相遇点分别设一个指针,每次各走一步,两个指针必定相遇,且相遇点为环入口点,也即为两个链表的第一个相同节点。

实现代码:

LinkList* FindLoopPort(LinkList *head)
{ 
    LinkList *slow =new  LinkList();
     LinkList *fast =new  LinkList();
    slow = head;*fast = head;
    while ( fast && fast->next ) 
    {
         slow = slow->next;
         fast = fast->next->next;
         if ( slow == fast )  break;
    }
    if (fast == NULL || fast->next == NULL)
        return NULL;
    slow = head;
    while (slow != fast)
    {
         slow = slow->next;
         fast = fast->next;
    }
    return slow;
}


<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),不适用于大链表
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值