slow

利用双指针寻找链表中点 利用快慢指针（双指针）同时指向头节点，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

在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。 示例 1: 输入: 4->2->1->3 输出: 1->2->3->4 示例 2: 输入: -1->5->3->4->0 输出: -1->0->3->4->5 首先归并排序 public static void mergeSort(int[] arr) { sort(arr, 0, arr.length - 1); } public static void sort(int[] arr, int L, int R) { if(L == R) { return; } int mid = L + ((R - L) >> 1); sort(arr, L, mid); sort(arr, mid + 1, R); merge(arr, L, mid, R); } public static void merge(int[] arr, int L, int mid, int R) { int[] temp = new int[R - L + 1]; int i = 0; int p1 = L; int p2 = mid + 1; // 比较左右两部分的元素，哪个小，把那个元素填入temp中 while(p1 <= mid && p2 <= R) { temp[i++] = arr[p1] < arr[p2] ?

1、jQuery slideToggle() 表示简单的 slide panel 效果。 < html > < head > < script type="text/javascript" src="jquery-1.7.1.min.js"></ script > < script type="text/javascript"> $(document).ready(function(){ $(".flip").click(function(){ $(".panel").slideToggle("slow"); }); }); </ script > < style type="text/css"> div.panel,p.flip { margin:0px; padding:5px; text-align:center; background:#e5eecc; border:solid 1px #c3c3c3; } div.panel { height:70px; display:none; } </ style > </ head > < body > < p class="flip">请点击这里</ p > < br /> < br /> < div class="panel" style="width:200px"> < p >JQuery</ p > < p >爱，别太认真

很多题解没有讲清楚非环部分的长度与相遇点到环起点那部分环之间为何是相等的这个数学关系。这里我就补充下为何他们是相等的。 假设非环部分的长度是x，从环起点到相遇点的长度是y。环的长度是c。 现在走的慢的那个指针走过的长度肯定是x+n1*c+y，走的快的那个指针的速度是走的慢的那个指针速度的两倍。这意味着走的快的那个指针走的长度是2(x+n1*c+y)。 还有一个约束就是走的快的那个指针比走的慢的那个指针多走的路程一定是环长度的整数倍。根据上面那个式子可以知道2(x+n1*c+y)-x+n1*c+y=x+n1*c+y=n2*c。 所以有x+y=(n2-n1)*c,这意味着什么？我们解读下这个数学公式：非环部分的长度+环起点到相遇点之间的长度就是环的整数倍。这在数据结构上的意义是什么？现在我们知道两个指针都在离环起点距离是y的那个相遇点，而现在x+y是环长度的整数倍，这意味着他们从相遇点再走x距离就刚刚走了很多圈，这意味着他们如果从相遇点再走x就到了起点。 那怎么才能再走x步呢？答：让一个指针从头部开始走，另一个指针从相遇点走，等这两个指针相遇那就走了x步此时就是环的起点。 class Solution { public: ListNode *detectCycle(ListNode *head) { ListNode *fast=head,*slow=head; while(fast!

慢查询有什么用？ 它能记录下所有执行超过long_query_time时间的SQL语句，帮你找到执行慢的SQL，方便我们对这些SQL进行优化。 测试用 MySQL 版本。 Server version: 5.6.10-log Source distribution 未做任何慢日志设置时。 mysql> show variables like "%query%"; +------------------------------+--------------------------------------+ | Variable_name | Value | +------------------------------+--------------------------------------+ | binlog_rows_query_log_events | OFF | | ft_query_expansion_limit | 20 | | have_query_cache | YES | | long_query_time | 10.000000 | | query_alloc_block_size | 8192 | | query_cache_limit | 1048576 | | query_cache_min_res_unit | 4096 | | query_cache

给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。 思路： public ListNode EntryNodeOfLoop(ListNode pHead) { if (pHead == null || pHead.next == null) return null; ListNode slow = pHead, fast = pHead; do { fast = fast.next.next; slow = slow.next; } while (slow != fast); fast = pHead; while (slow != fast) { slow = slow.next; fast = fast.next; } return slow; } 来源： https://my.oschina.net/u/3973793/blog/3129096

/* 判断单链表是否存在环 1）暴力：双层循环遍历（n^2） 2）双指针：快指针fast=NULL,慢指针slow=NULL int judge(link head) { if(NULL==head) return false; link fast = head, slow = head; while(slow!=NULL && fast!=NULL) { slow = slow->next; fast = fast->next->next; if(slow==fast) { return true; } } return false; } 计算带环单链表的长度 int count(link head) { if(NULL==head) return false; link fast = head, slow = head; while(slow!=NULL && fast!=NULL) { slow = slow->next; fast = fast->next->next; if(slow==fast) { flag = true; break; } } if(flag) { int ans = 1; slow = slow->next; while(slow!=fast) { ans++; slow = slow->next; } return ans ; } return

题目 请判断一个链表是否为回文 链表 ： 时间复杂度O(n) 空间复杂度O(1) 快慢指针 快慢指针非常适合这种有中点的问题，并且在移动快慢指针的过程，将原有的链表拆成了两部分(注意：对原链表进行了操作，若为工程不该这么做，但是题目要求空间复杂度O(1))，然后再往后逐一比较。 注意点： 头插法 奇偶情况不同 def isPalindrome ( self , head : ListNode ) - > bool : if ( not head or not head . next ) : return True pre = None # 和 slow 同步 curr = None # 记录新链的头(头插法) fast = slow = head while fast and fast . next : # fast不为空的判断一定要有且在前，根据：逻辑短路 pre = slow slow = slow . next fast = fast . next . next pre . next = curr # 让新点插到新链表的头 curr = pre # 让新点成为新链的头 # while结束，此时slow指向中点，而fast指向最后，若fast不为空，则链表长为奇 if fast : slow = slow . next # 若为奇数，则slow在中点

来源： https://www.cnblogs.com/wwbb/p/11682007.html

1 /** 2 * Definition for singly-linked list. 3 * struct ListNode { 4 * int val; 5 * ListNode *next; 6 * ListNode(int x) : val(x), next(NULL) {} 7 * }; 8 */ 9 class Solution { 10 public: 11 ListNode *detectCycle(ListNode *head) { 12 ListNode* fast=head; 13 ListNode* slow=head; 14 while(1){ 15 if(fast==NULL||fast->next==NULL) 16 return nullptr; 17 fast=fast->next->next; 18 slow=slow->next; 19 if(fast==slow) 20 break; 21 } 22 ListNode* p=head; 23 while(p!=slow){ 24 p=p->next; 25 slow=slow->next; 26 } 27 return slow; 28 } 29 }; 先用快慢指针判定是否存在环 令入环前长度为x，环长为c，两个指针在距离入环节点k处相遇，此时快指针走了m次环，慢指针走了n次环 fast