slow

输入两个链表，找出它们的第一个公共结点。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的） /** * 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 (

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

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

普通的方法很简单，首先遍历一遍单链表以确定单链表的长度L。然后再次从头节点出发循环L/2次找到单链表的中间节点。算法复杂度为O(L+L/2)=O(3L/2)。 能否再优化一下这个时间复杂度呢？有一个很巧妙的方法： 设置两个指针* fast、*slow都指向单链表的头节点。其中* fast的移动速度是* slow的2倍。当* fast指向末尾节点的时候，slow正好就在中间了。 C源代码如下： Java代码 void locate(LinkedList *head){ LinkedList *fast, *slow; fast=slow=head; while (fast->next!=NULL){ //fast的移动速度是slow的2倍 if (fast->next->next!=Null){ fast=fast->next->next; slow=slow->next; } else { fast=fast->next; } } } 来源： https://www.cnblogs.com/c-cloud/archive/2013/04/19/3031679.html

26. 删除数组中的新元素 给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。 不要使用额外的数组空间，你必须在原地修改输入数组并在使用 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。 class Solution { public int removeDuplicates ( int [ ] nums ) { //i指向要保留的数； //j遍历整个数组 int i = 0 ; for ( int j = 1 ; j < nums . length ; j ++ ) { if ( nums [ i ] != nums [ j ] ) { i ++ ; //找到了需要保留的数字，让i后移，腾出位置 nums [ i ] = nums [ j ] ; } } return i + 1 ; } } 633. 平方数之和 给定一个非负整数 c ，你要判断是否存在两个整数 a 和 b，使得 a2 + b2 = c。 示例1: 输入: 5 输出:

code148: Sort List Add to List Share Sort a linked list in O(n log n) time using constant space complexity. Example 1: Input: 4->2->1->3 Output: 1->2->3->4 Example 2: Input: -1->5->3->4->0 Output: -1->0->3->4->5 解答： 看到logn基本确定是有二分的想法在里面 我的想法： 类似快排，每个链的head作为pivot，然后遍历，小的新建链放在左边，大的新建链放在右边。得到三个（left, pivot, right），然后进行整合为新链。内部进行递归细分整合。 代码： class Solution : ###TLE ###quick sort def sortList ( self , head : ListNode ) - > ListNode : return self . sort_node ( head ) def sort_node ( self , node ) : #print('#') if not node : return None else : #print(node.val) new_node1 , new_node2 = ListNode ( 0 ) ,

LeetCode链接： 142. 环形链表 II /** * 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 ) { ListNode fast = head , slow = head ; while ( true ) { if ( fast == null || fast . next == null ) return null ; fast = fast . next . next ; slow = slow . next ; if ( fast == slow ) break ; } fast = head ; while ( slow != fast ) { slow = slow . next ; fast = fast . next ; } return fast ; } } 来源： CSDN 作者： 玉树临风你卓哥 链接： https://blog.csdn.net/songzhuo1991/article

参考文章： 判断链表是否相交： http://treemanfm.iteye.com/blog/2044196 一、单链表反转 链表节点 public class Node { private int record; private Node nextNode; public Node(int record) { super(); this.record = record; } } View Code 构建链表 public static Node creatLinkedList() { Node head = new Node(0); Node tmp = null; Node cur = null; for (int i = 1; i < 10; i++) { tmp = new Node(i); if (1 == i) { head.setNextNode(tmp); } else { cur.setNextNode(tmp); } cur = tmp; } return head; } View Code 递归实现 public static Node reverse(Node head) { if (null == head || null == head.getNextNode()) { return head; } Node reversedHead =

61. Rotate List 方法一：做k次rotation。 1.corner case需要考虑 2.当k远远大于的计算量的时候，记得算出链表长度并对长度求余。 class Solution { public ListNode rotateRight(ListNode head, int k) { if(head == null) return null; if(head.next == null) return head; int n = 0; ListNode dummy = new ListNode(0); dummy.next = head; ListNode cur = head; while(cur != null){ n++; cur = cur.next; } k %= n; for(int i = 0; i < k; i++){ ListNode pre = dummy; ListNode last = dummy.next; while(last.next != null){ pre = pre.next; last = last.next; } last.next = dummy.next; dummy.next = last; pre.next = null; } return dummy.next; } } 方法二： 原理是先遍历整个链表获得链表长度

慢指针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 =