[LeetCode]141. Linked List Cycle ★

题目描述

Given a linked list, determine if it has a cycle in it.

To represent a cycle in the given linked list, we use an integer pos which represents the position (0-indexed) in the linked list where tail connects to. If pos is -1, then there is no cycle in the linked list.
题目大意：给定一个链表，试判断链表中是否有环。为了代表给定链表中有环，给定一个数pos，pos范围是（0-indexed），表示链表中最后一个节点指向链表中的位置，当pos为-1时，表示链表中没有环。自己完善的函数是没有pos的值的，所以需要遍历链表。

样例

Example 1:

Input: head = [3,2,0,-4], pos = 1
Output: true
Explanation: There is a cycle in the linked list, where tail connects to the second node.

Example 2:

Input: head = [1,2], pos = 0
Output: true
Explanation: There is a cycle in the linked list, where tail connects to the first node.

Example 3:

Input: head = [1], pos = -1
Output: false
Explanation: There is no cycle in the linked list.

python解法

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        d = {}
        r = False
        while head:
            if head.next in d:
                r = True
                break
            else:
                d[head.next] = 0
            head = head.next
        return r

Runtime: 44 ms, faster than 33.19% of Python online submissions for Linked List Cycle.
Memory Usage: 19.2 MB, less than 9.22% of Python online submissions for Linked List Cycle.
题后反思：无

C语言解法

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

Runtime: 12 ms, faster than 21.99% of C online submissions for Linked List Cycle.
Memory Usage: 8.5 MB, less than 100.00% of C online submissions for Linked List Cycle.
题后反思：

1. fast指针每次移动两个位置，slow每次移动一个位置，如果链表中有环，那么两个指针迟早要相遇.

文中都是我个人的理解，如有错误的地方欢迎下方评论告诉我，我及时更正，大家共同进步