di_ko的博客

思路：先通过快慢指针找到中间节点，把后半部分的链表翻转，再和前半部分的链表进行值比较，比较完后将后半部分的链表再翻转回来代码：class Solution { public boolean isPalindrome(ListNode head) { if(head==null){ return true; } ListNode tail=endOfHead(head); ListNode second=reverseList(tail.next); .

思路：归并排序是链表排序的最佳方案，时间复杂度是O(nlogn)的排序算法包括归并排序、堆排序和快速排序（快速排序的最差时间复杂度是O(n^2）代码：class Solution { public ListNode sortList(ListNode head) { if(head==null){ return head; } int length=0; ListNode node=head; while(node!=null){ //...

思路：自定义一个链表+哈希表（哈希不需要自己写）代码：class LRUCache { //自定义一个链表 class DlinkedNode{ int key; int value; DlinkedNode pre; DlinkedNode next; public DlinkedNode(){}; public DlinkedNode(int _key,int _value){ key=_key; value=_value; } } .

思路：快慢指针，这类链表题目一般都是使用双指针法解决的例如：寻找距离尾部第K个节点、寻找环入口、寻找公共尾部入口等代码：public class Solution { public ListNode detectCycle(ListNode head) { if(head==null||head.next==null){ return null; } ListNode slow=head; ListNode fast=head; //第一次相遇.

思路：快慢指针，也就是龟兔赛跑代码：public class Solution { public boolean hasCycle(ListNode head) { if(head==null||head.next==null){ return false; } ListNode slow=head; ListNode fast=head.next; while(slow!=fast){ if(fast==null||fast.next==n.

思路：先对数组进行分治（拆分），然后再两两排序（合并）代码：class Solution { public ListNode mergeKLists(ListNode[] lists) { if(lists==null||lists.length==0) return null; return merge(lists,0,lists.length-1); } private ListNode merge(ListNode[] lists,int low,int .

思路：就是链表的遍历难点是进位代码：class Solution { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { ListNode pre=new ListNode(0); ListNode cur=pre; int carry=0; while(l1!=null||l2!=null){ int x=l1==null?0:l1.val; int y=l2==null?0:l2..

思路：A和B都走两回：A先把A的走完，再走B直到相交B先把B的走完，再走A直到相交若有相交点，必相交；若无，则是都为null设相交点为c：A走了：a+(b-c)B走了：b+(a-c)代码：public class Solution { public ListNode getIntersectionNode(ListNode headA, ListNode headB) { ListNode A=headA; ListNode B=..

思路：对二叉树进行中序遍历，也就是左、根、右的顺序，最后返回head即可// 打印中序遍历void dfs(Node root) { if(root == null) return; dfs(root.left); // 左 System.out.println(root.val); // 根 dfs(root.right); // 右}代码：/*// Definition for a Node.class Node { publ.

思路：方法一：使用哈希表方法二：原地修改代码：方法一：/*// Definition for a Node.class Node { int val; Node next; Node random; public Node(int val) { this.val = val; this.next = null; this.random = null; }}*/class Solut.

思路：创建一个新链表，将排好序的节点一一加入代码：/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */class Solution { public ListNode mergeTwoLists(ListNode l1, ListN.

思路：方法一：迭代方法二：递归（*）代码：方法一：class Solution { public ListNode reverseList(ListNode head) { ListNode cur=head,pre=null,next=null; while(cur!=null){ next=cur.next; //将前一步的结果加上 cur.next=pre; //放在pre中，又事先了一个节点 pre=cur; //前进了.

思路：1）方法一：先循环一遍链表，得出长度。再遍历链表到指定k的位置2）方法二：双指针，指针间的间隔为k3）方法三：栈，就不需要事先遍历一遍链表获取长度了（超出时间限制）代码：方法一：/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * }.

思路：就是一道典型普通的删除链表的题目代码：/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */class Solution { public ListNode deleteNode(ListNode head, int val) .

思路：数组的插入排序是从最后一个从后往前遍历找到合适的位置插入，而链表不能往前遍历，则需要一个带头节点的指针，从前往后遍历找到合适的位置插入代码：class Solution { public ListNode insertionSortList(ListNode head) { //是return head而不是0 if(head==null) return head; //只是一个空链表，不带头节点 ListNode hair=new ListNode(0);.

思路：1）设置一个带头节点的指针hair，这个指针不动，用于最后返回链表2）设置一个pre，一个end指针，都放在hair处，也就是第一个节点的前一个节点pre用于每次翻转完记住起始位置，end用于往后遍历k个节点3）每次遍历设置一个start指针，用于和end传入函数中进行翻转操作代码：class Solution { public ListNode reverseKGroup(ListNode head, int k) { ListNode hair=.

思路：相当于多个合并2个升序链表的操作，将k个简化为2个实际上就是利用分治法合并2个升序链表可查看（https://blog.csdn.net/di_ko/article/details/115062966）class Solution { public ListNode mergeKLists(ListNode[] lists) { if(lists==null||lists.length==0) return null; return merge(lists,.

思路：新建一条新的链表，比较传入的2个链表的第一个节点，将较小值的传入新的链表关键在于，声明新链表时，要创建2个指针，一个指头，一个随着过程变动还要为传入的2个链表各自创建1一个随过程变动的指针class Solution { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { if(l1==null||l2==null){ return l1==null?l2:l1;.