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(1)（即，常量）内存解决此问题吗？ 解题思路 这道题目可以用快慢指针解决。 快指针每次走 2 步，慢指针每次走 1 步。如果快指针追上慢指针，则说明链表中存在环（就像 2 个人在操场上跑步，一个跑得快，一个跑得慢，跑得快的那个最终一定会追上慢的那个）。 代码 class Solution { /** * 使用快慢指针，快指针每次走2步，慢指针每次走1步，如果快指针追上了慢指针，则说明存在环 */ public boolean hasCycle ( ListNode head ) { if ( head == null || head . next == null ) { return false ; }

慢指针slowPtr每次后移1个结点。快指针fastPtr每次后移2个结点 function isLinkedListContainsLoop( head){ if(head==null){ return false; } let slowPtr=head; let fastPtr=head; while(slowPtr.next!=null && fastPtr.next.next!=null){ slowPtr=slowPtr.next; fastPtr=fastPtr.next.next; if(slowPtr==fastPtr){ return true; } } return false; } 衍生问题1------找出环的入口点（起点） 当fast按照每次2步，slow每次一步的方式走，发现fastPtr和slowPtr重合，确定了单向链表有环路。接下来，让slowPrt回到链表的头部，然后slowPtr和fastPtr各自从自己的位置（fastPtr从两个指针相遇的位置position出发）沿着链表出发，每次步长1，那么当fastPtr和slowPtr再次相遇的时候，就是环路的入口了。 function findLinkedListLoopBegin(head) { if (head == null) { return null; } let slowPtr =

利用双指针寻找链表中点 利用快慢指针（双指针）同时指向头节点，fast指针每次走两步，slow指针每次走一步，当fast指针到达链表尽头时，slow指针就处于链表中点处。 Node * middle ( Node * head ) { Node * fast , * slow ; fast = slow = head ; while ( fast != null && fast . next != null ) { fast = fast . next . next ; slow = slow . next ; return slow ; //slow即在中间位置 } 如果链表长度是奇数时，此时slow 正好为中点，如果为偶数，那么slow位置是中间偏右。 明天考试，今天写的有点少… 来源： CSDN 作者： 邜玥 链接： https://blog.csdn.net/weixin_45678985/article/details/103846425

题目要求 Linked List Cycle Given a linked list, determine if it has a cycle in it. Follow up: Can you solve it without using extra space? 如何判断一个单链表中有环？ Linked List Cycle II Given a linked list, return the node where the cycle begins. If there is no cycle, return null . Follow up: Can you solve it without using extra space? 如何找到环的第一个节点？ 分析 一开始使用了复杂度O(n^2)的方法，使用两个指针a, b。a从表头开始一步一步往前走，遇到null则说明没有环，返回false；a每走一步，b从头开始走，如果遇到b==a.next，则说明有环true，如果遇到b==a，则说明暂时没有环，继续循环。 后来找到了复杂度O(n)的方法，使用两个指针slow,fast。两个指针都从表头开始走，slow每次走一步，fast每次走两步，如果fast遇到null，则说明没有环，返回false；如果slow==fast，说明有环，并且此时fast超了slow一圈，返回true。

题目 　　一个链表中包含环，请找出该链表的环的入口结点。 分析 　　首先检查该链表是否为环，设置一个快指针fast，每次走两步，一个慢指针slow，每次走一步。若fast==null或fast.next==null，表示不存在环；当fast==slow时，存在环。 将fast指向链表头，每次走一步，slow还是每次走一步，当fast与slow相遇时，即为环的入口结点。 代码 1 　　public ListNode EntryNodeOfLoop(ListNode pHead){ 2 if(pHead==null) 3 return null; 4 ListNode slow = pHead, fast = pHead; 5 while(true){ 6 if(fast==null) 7 return null; 8 slow = slow.next; 9 fast = fast.next.next; 10 if(slow==fast) 11 break; 12 } 13 fast = pHead; 14 while(fast!=slow){ 15 fast = fast.next; 16 slow = slow.next; 17 } 18 return fast; 19 } 来源： https://www.cnblogs.com/jiqianqian/p/6951651.html

题目链接: https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/ 题目描述: 给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。 不要使用额外的数组空间，你必须在 原地修改输入数组 并在使用 O(1) 额外空间的条件下完成。 示例: 示例 1: 给定数组 nums = [1,1,2], 函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。 你不需要考虑数组中超出新长度后面的元素。 示例 2: 给定 nums = [0,0,1,1,1,2,2,3,3,4], 函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。 你不需要考虑数组中超出新长度后面的元素。 思路: 因为 nums 是排好训的, 我们用快慢指针,快指针指向重复数字的最后一个,慢指针指向要和快指针交换数字的位置. 时间复杂度: \(O(n)\) ; 空间复杂度: \(O(1)\) 关注我的 知乎专栏 ,了解更多解题技巧!我们一起进步. 代码: python class Solution: def removeDuplicates(self, nums: List[int]) -> int: slow = 0

题目链接: https://leetcode-cn.com/problems/remove-element/ 题目描述: 给定一个数组 nums 和一个值 val ，你需要 原地 移除所有数值等于 val 的元素，返回移除后数组的新长度。 不要使用额外的数组空间，你必须在 原地修改输入数组 并在使用 O(1) 额外空间的条件下完成。 元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。 示例: 示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。 示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。 注意这五个元素可为任意顺序。 你不需要考虑数组中超出新长度后面的元素。 思路: 思路1: 用双指针,一个从头向后扫,一个从尾向前扫,头指针把等于 val 和尾指针不等于 val 调换即可. 时间复杂度: \(O(n)\) 思路2: 依次把不等于 val 往前移, 题目中没说不可以改变原来的数组的数值,所以,可以交换,也可以覆盖! 时间复杂度: \(O(n)\) 关注我的 知乎专栏 ,了解更多的解题技巧,大家共同进步! 代码:

在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。 示例 1: 输入: 4->2->1->3 输出: 1->2->3->4 示例 2: 输入: -1->5->3->4->0 输出: -1->0->3->4->5 思路： 1.归并排序，一般都是使用递归版本，递归版本不能保证常数级的时间复杂度 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ class Solution { public ListNode sortList ( ListNode head ) { //归并排序 if ( head == null || head . next == null ) //head.next == null别忘记了 return head ; ListNode fast = head . next ; ListNode slow = head ; int len = 0 ; while ( fast != null && fast . next != null ) { slow = slow . next ; fast = fast . next .

1. 题目描述 2. 思路及代码 2.1 思路 快慢指针法，慢指针 slow 始终指向符合题意的最后一个数字，快指针 fast 逐个扫描所有元素 若 nums[slow]==nums[fast] ， ++fast 若 nums[slow]!=nums[fast] ， ++slow ，再使用 nums[fast] 更新 nums[slow] 处的值 2.2 代码 class Solution { public : int removeDuplicates ( vector < int > & nums ) { int n = nums . size ( ) ; if ( n <= 1 ) return n ; int slow = 0 ; for ( int fast = 1 ; fast != n ; ++ fast ) { if ( nums [ slow ] != nums [ fast ] ) { ++ slow ; nums [ slow ] = nums [ fast ] ; } } return slow + 1 ; } } ; 来源： CSDN 作者： weixin_42075898 链接： https://blog.csdn.net/weixin_42075898/article/details/103738855

难度：中等 题目描述： 思路总结 ：这个和上次那个环形链表（判断是否有环）一样，看到之后想到用list或者hash存。但是这里把双指针又巧妙的利用上了。感概一句，双指针简直无所不能啊。分为两个阶段，具体思路看代码中的描述，这里就不多说了。 题解一： # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None class Solution : def detectCycle ( self , head : ListNode ) - > ListNode : #思路：第一阶段，快慢指针相遇，距环头F个节点。2(F+b)~F+b；第二阶段，等速指针，相遇即环头 if not head or not head . next or not head . next . next : return fast = head . next . next slow = head . next while fast != slow : fast = fast . next . next slow = slow . next fast = head while fast != slow : fast = fast . next slow =