fast

问题描述 给定一个链表，判断链表中是否有环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 示例 ： 输入：head = [3,2,0,-4], pos = 1 输出：true 解释：链表中有一个环，其尾部连接到第二个节点。 双指针法 快慢指针，快指针每走两步慢指针走一步，二者相遇的话说明有环 代码 class Solution : def hasCycle ( self , head : ListNode ) - > bool : fast = head slow = head while fast and slow and fast . next : fast = fast . next . next slow = slow . next if slow == fast : return True return False 运行结果 O(1)空间复杂度居然只击败了7%的提交 看了讨论区的大佬们的破坏链表元素和"bjfuvth"做法之后。。。无语.jpg 来源： CSDN 作者： Formaterror 链接： https://blog.csdn.net/fromatlove/article/details/104759276

环形链表 描述 给定一个链表，判断链表中是否有环。 思路和代码 思路1:用一个哈希表,将每一个遍历到的节点加入哈希表中,如果遍历到节点已经出现在了哈希表中则证明有环. 思路2:一个指针走一步,一个指针走两步,若有环,则两个指针必会相遇. /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public : bool hasCycle ( ListNode * head ) { ListNode * fast = head ; ListNode * slow = head ; while ( fast && fast - > next ) { slow = slow - > next ; fast = fast - > next - > next ; if ( fast == slow ) return true ; } return false ; } } ; 环形链表2 描述 在有环的基础上,返回入环的第一个节点 快指针和慢指针,快指针走两步,慢指针走一步,若相遇则有环 相遇之后,快指针返回head,慢指针在相遇这一点

输入两个链表，找出它们的第一个公共结点。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的） /** * Definition for singly-linked list. * class ListNode { * int val; * ListNode next; * ListNode(int x) { * val = x; * next = null; * } * } */ public class Solution { public ListNode detectCycle ( ListNode head ) { if ( head == null ) { return null ; } ListNode meetNode = meetingNode ( head ) ; if ( meetNode == null ) { //说明无环 return null ; } ListNode fast = head ; ListNode slow = meetNode ; while ( slow != fast ) { slow = slow . next ; fast = fast . next ; } return slow ; } //寻找相遇节点，如果无环，返回null public ListNode meetingNode (

代码思路：利用快慢指针遍历链表，若存在环形链表，两指针必相遇，否则快指针会先遍历完成 class Solution : def hasCycle ( self , head : ListNode ) - > bool : show = fast = head while fast and fast . next : show = show . next fast = fast . next . next if show == fast : return True return False 来源： CSDN 作者： jkn7 链接： https://blog.csdn.net/m0_37656366/article/details/104745759

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 说明：不允许修改给定的链表。 示例 1： 输入：head = [3,2,0,-4], pos = 1 输出：tail connects to node index 1 解释：链表中有一个环，其尾部连接到第二个节点。 示例 2： 输入：head = [1,2], pos = 0 输出：tail connects to node index 0 解释：链表中有一个环，其尾部连接到第一个节点。 示例 3： 输入：head = [1], pos = -1 输出：no cycle 解释：链表中没有环。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/linked-list-cycle-ii 方法一：利用集合（set）的无序的不重复元素序列的特性。把visited的节点存在set里，延用环形链表 I的做法 # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next

234. 回文链表 请判断一个链表是否为回文链表。 示例 1: 输入: 1->2 输出: false 示例 2: 输入: 1->2->2->1 输出: true 进阶： 你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？ /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ class Solution { public boolean isPalindrome ( ListNode head ) { // 要实现 O(n) 的时间复杂度和 O(1) 的空间复杂度，需要翻转后半部分 if ( head == null || head . next == null ) { return true ; } ListNode fast = head ; ListNode slow = head ; // 根据快慢指针，找到链表的中点 while ( fast . next != null && fast . next . next != null ) { fast = fast . next . next ; slow = slow . next ; } slow

题目链接： https://leetcode-cn.com/problems/linked-list-cycle-lcci/ 给定一个有环链表，实现一个算法返回环路的开头节点。 有环链表的定义：在链表中某个节点的next元素指向在它前面出现过的节点，则表明该链表存在环路。 示例 1： 输入：head = [3,2,0,-4], pos = 1 输出：tail connects to node index 1 解释：链表中有一个环，其尾部连接到第二个节点。 示例 2： 输入：head = [1,2], pos = 0 输出：tail connects to node index 0 解释：链表中有一个环，其尾部连接到第一个节点。 示例 3： 输入：head = [1], pos = -1 输出：no cycle 解释：链表中没有环。 1 struct ListNode *detectCycle(struct ListNode *head) { 2 struct ListNode *fast=head,*slow=head; 3 while(fast&&fast->next){ 4 slow=slow->next; 5 fast=fast->next->next; 6 if(fast==slow) break; 7 } 8 if (fast==NULL||fast->next=

快慢指针 快慢指针中的快慢指的是移动的步长，即每次向前移动速度的快慢。 例如可以让快指针每次沿链表向前移动2，慢指针每次向前移动1次。 快慢指针的应用 （1）判断单链表是否存在环 如果链表存在环，就好像操场的跑道是一个环形一样。此时让快慢指针都从链表头开始遍历，快指针每次向前移动两个位置，慢指针每次向前移动一个位置；如果快指针到达NULL，说明链表以NULL为结尾，没有环。如果快指针追上慢指针，则表示有环。代码如下： bool HasCircle(Node *head) { if(head == NULL) return false; Node *slow = head, *fast = head; while(fast != NULL && fast->next!=NULL) { slow = slow->next; //慢指针每次前进一步 fast = fast->next->next;//快指针每次前进两步 if(slow == fast) //相遇，存在环 return true; } return false; } （2）在有序链表中寻找中位数 快指针的移动速度是慢指针移动速度的2倍，因此当快指针到达链表尾时，慢指针到达中点。 程序还要考虑链表结点个数的奇偶数因素，当快指针移动x次后到达表尾（1+2x），说明链表有奇数个结点，直接返回慢指针指向的数据即可。

287. 寻找重复数 给定一个包含 n + 1 个整数的数组 nums，其数字都在 1 到 n 之间（包括 1 和 n），可知至少存在一个重复的整数。假设只有一个重复的整数，找出这个重复的数。 示例 1: 输入: [1,3,4,2,2] 输出: 2 示例 2: 输入: [3,1,3,4,2] 输出: 3 说明： 不能更改原数组（假设数组是只读的）。 只能使用额外的 O(1) 的空间。 时间复杂度小于 O(n2) 。 数组中只有一个重复的数字，但它可能不止重复出现一次。 PS： 快慢指针思想, fast 和 slow 是指针, nums[slow] 表示取指针对应的元素 注意 nums 数组中的数字都是在 1 到 n 之间的(在数组中进行游走不会越界), 因为有重复数字的出现, 所以这个游走必然是成环的, 环的入口就是重复的元素, 即按照寻找链表环入口的思路来做 class Solution { public int findDuplicate ( int [ ] nums ) { int fast = 0 , slow = 0 ; while ( true ) { fast = nums [ nums [ fast ] ] ; slow = nums [ slow ] ; if ( slow == fast ) { fast = 0 ; while ( nums [ slow ]

287. 寻找重复数 这个题还蛮有意思的 class Solution { public int findDuplicate ( int [ ] nums ) { int slow = 0 ; //慢指针 int fast = 0 ; //快指针 while ( true ) { //类似环找出口。。 fast = nums [ nums [ fast ] ] ; slow = nums [ slow ] ; if ( fast == slow ) { fast = 0 ; while ( slow != fast ) { fast = nums [ fast ] ; slow = nums [ slow ] ; } return fast ; } } } } 来源： CSDN 作者： 竺一辉 链接： https://blog.csdn.net/SteveHui1995/article/details/104683621