fast

题目描述： 给定一个链表，判断链表中是否有环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 示例 1： 输入：head = [3,2,0,-4], pos = 1 输出：true 解释：链表中有一个环，其尾部连接到第二个节点。 示例 2： 输入：head = [1,2], pos = 0 输出：true 解释：链表中有一个环，其尾部连接到第一个节点。 示例 3： 输入：head = [1], pos = -1 输出：false 解释：链表中没有环。 思路分析： 思路一: 哈希, 空间复杂度 O(n) 这个很好考虑, 把遍历过的节点记录,当发现遍历的节点下一个节点遍历过, 说明有环 public class Solution { public boolean hasCycle(ListNode head) { Set<ListNode> lookup = new HashSet<>(); ListNode p = head; while (p != null) { lookup.add(p); if (lookup.contains(p.next)) return true; p = p.next; } return false; } } 思路二: 快慢指针, 空间复杂度 O(1)

单链表中的环二。题意是给一个链表，如果这个链表中有环，请return环的起点；若没有，return null。找是否有环可以参照 [LeetCode] 141. Linked List Cycle 的讲解。至于怎么找到环的起点，我这里引用一个非常好的讲解， https://www.cnblogs.com/hiddenfox/p/3408931.html 因为快慢指针的速度是一个2步一个1步，所以当两个指针相遇的时候，fast走过的长度一定是slow的两倍。两者相遇的地方一定是环的起点。至于证明，直接参照引用贴。 时间O(n) 空间O(1) 1 /** 2 * @param {ListNode} head 3 * @return {ListNode} 4 */ 5 var detectCycle = function(head) { 6 // corner case 7 if (head === null || head.next === null) { 8 return null; 9 } 10 11 // normal case 12 let slow = head; 13 let fast = head; 14 while (fast !== null && fast.next !== null) { 15 slow = slow.next; 16 fast = fast

单链表中的环。题意很简单，找出链表中是否有环。例子，这样就是有环的。 思路是用快慢指针，慢指针每走一步，快指针走两步。如果快慢指针在某个地方相遇了，说明有环；否则快指针就会遍历到链表尾部从而会退出循环。 时间O(n) 空间O(1) 1 /** 2 * @param {ListNode} head 3 * @return {boolean} 4 */ 5 var hasCycle = function(head) { 6 // corner case 7 if (head === null || head.next === null) { 8 return false; 9 } 10 11 // normal case 12 let slow = head; 13 let fast = head; 14 while (fast !== null && fast.next !== null) { 15 slow = slow.next; 16 fast = fast.next.next; 17 if (slow === fast) { 18 return true; 19 } 20 } 21 return false; 22 }; 来源： https://www.cnblogs.com/aaronliu1991/p/11828784.html

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 说明：不允许修改给定的链表。 示例 1： 输入：head = [3,2,0,-4], pos = 1 输出：tail connects to node index 1 解释：链表中有一个环，其尾部连接到第二个节点。 解法： 　　 public static class ListNode { private int val; private ListNode next; public ListNode(int val) { this.val = val; } } View Code public static ListNode detectCycle(ListNode head) { /*定义一个快指针，每次走2步*/ ListNode fast = head; /*定义一个慢指针，每次走1步*/ ListNode slow = head; /*标识是否有环*/ boolean haveCycle = false; /*让2个指针第一次相遇*/ while (fast != null && fast.next != null) { slow = slow

I learned this trick from hitonanode 's submission on AtCoder. The trick is like struct fast_ios { fast_ios(){ cin.tie(0); ios::sync_with_stdio(false); cout << fixed << setprecision(20); }; } fast_ios_; What I used to do is like #define FAST_READ ios::sync_with_stdio(false); cin.tie(nullptr); int main() { FAST_READ cout << fixed << setprecision(10); // ... } using this trick, the code becomes struct fast_ios { fast_ios(){ cin.tie(nullptr); ios::sync_with_stdio(false); cout << fixed << setprecision(10); }; } fast_ios_; int main() { // ... } I think macros are better avoided when alternatives

给定一个链表，判断链表中是否有环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 示例 1： 输入：head = [3,2,0,-4], pos = 1 输出：true 解释：链表中有一个环，其尾部连接到第二个节点。 解法1: public static boolean hasCycle(ListNode head) { /*如果头指针不为null继续下面判断*/ if (head != null) { /*定义一个快指针，每次走2步*/ ListNode fast = head; /*定义一个慢指针，每次走1步*/ ListNode slow = head; while (fast != null && fast.next != null) { slow = slow.next; fast = fast.next.next; /*当快慢指针相遇时说明有环，为什么有环快慢指针会相遇呢，因为2个跑速不同的人在一个跑道里跑圈，最后相遇时跑的快的是跑的慢的人跑的距离是圈的n倍*/ if (slow == fast) { return true; } } } return false; } View Code 来源： https://www.cnblogs.com/wuyouwei/p

给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。 示例 1: 输入: 1->1->2 输出: 1->2 示例 2: 输入: 1->1->2->3->3 输出: 1->2->3 解答： 首先此链表是排序的链表，不会出现相同的元素中间有其它的元素。 解法： public static ListNode deleteDuplicates(ListNode head) { /*定义一个哑节点*/ ListNode dumb=new ListNode(0); /*哑节点的下一个节点指向头节点*/ dumb.next=head; /*快指针*/ ListNode fast=head; /*慢指针*/ ListNode slow=dumb; /*当快指针不为null时继续*/ while (fast!=null){ /*如果fast到了尾节点或fast的数字与fast的next的数字不一样时进入*/ if(fast.next==null||fast.val!=fast.next.val){ /*如果相邻，则slow引用指向fast所指的对象*/ if(slow.next==fast){ slow=fast; }else{ /*如果不相邻，则说明中间存在重复元素，将slow的下一个指向fast，这样就抹去了相同的元素其中的一个*/ slow.next=fast; /

题目 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 说明：不允许修改给定的链表。 来源：力扣（LeetCode） 链接： https://leetcode-cn.com/problems/linked-list-cycle-ii 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 题解 step1 使用快慢指针判断有无环。使每次快指针走2步，慢指针走1步。 PS 两指针并不一定在慢指针走环形第一圈就相遇。当非环形部分很长，环形一圈很短的情况易见。 若快指针每次走三步，若慢指针进入环形后，两支针相差奇数圈，但每次快追慢距离为2，则永远不可能追上。（待验证结论正确性？） step2 画图理解。 设链表起点到环形起点的距离为x，环形起点到快慢指针相遇点距离为y，环形的长度为c。由同一时刻快指针是慢指针走的距离2倍，有 2*(x+n1*c+y)=x+n2*c+y <=> x+y=(n2-n1)*c ，理解式子含义为从环中任意一点走x+y步，还能回到这点 =>（从起始点走了y步的）在相遇点的指针再走x步，还能回到环形起始点 故让在相遇点的慢指针再走x步即可找到环形入口 代码 /** *

Given a linked list, return the node where the cycle begins. If there is no cycle, return null . 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. Note: Do not modify the linked list. Example 1: Input: head = [3,2,0,-4], pos = 1 Output: tail connects to node index 1 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: tail connects to node index 0

1 package offer; 2 3 import java.util.HashMap; 4 import java.util.List; 5 import java.util.Map; 6 7 import Struct.ListNode; 8 9 /** 10 * 给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。 11 * @author 爱不会绝迹 12 * 13 */ 14 public class Problem32 { 15 /** 16 * 我的解法，利用map标记每一个节点的出现的次数，第一个为出现次数为2的节点就是入口节点 17 * @param pHead 18 * @return 19 */ 20 public static ListNode EntryNodeOfLoop(ListNode pHead) 21 { 22 Map<ListNode,Integer> map = new HashMap<>(); 23 ListNode p = pHead; 24 while(p!=null){ 25 if(map.get(p)==null){ 26 map.put(p, 1); 27 }else{ 28 return p; 29 } 30 p = p.next; 31 } 32 return null; 33 } 34 35 /**