weixin_39248750的博客

思路：类似剑指offer58 左旋转字符串public ListNode rotateRight(ListNode head, int k){ if(head==null||head.next==null||k==0) return head; int count=1; ListNode node=head; while(node.next!=null){ count++; node=nod

题目：给定一个奇数位升序，偶数位降序的链表，将其重新排序。输入: 1->8->3->6->5->4->7->2->NULL输出: 1->2->3->4->5->6->7->8->NULL思路：首先，将链表拆分成两个，一个偶数降序链表，一个奇数升序链表。其次，将降序的偶数链表逆序为升序。最后，将两个链表合并。三个步骤其实都有对应的题目。public static ListNode

方法一：非递归public ListNode swapPairs(ListNode head){ ListNode res=new ListNode(0); res.next=head; ListNode cur=res; while (cur.next!=null&&cur.next.next!=null){ ListNode start=cur.next; ListNod

思路：根据题意，可以理解为重排链表的结果是：先找到链表的中间节点，将链表一分为二，然后将第二个链表逆序，逆序得到的链表和第一个链表按照升序合并，即为重排链表。public static void reorderList(ListNode head){ if(head==null) return; ListNode mid=FindMidNode(head); ListNode newHead=mid.next; mid.next=null

思路：把每个链表的头结点都入堆，堆为小顶堆，堆顶一定堆内最小值，将最小值出堆，并把它的下一个结点放入堆中继续排序，直到堆内为空。public ListNode mergeKLists(ListNode[] lists){ if(lists.length==0||lists==null) return null; PriorityQueue<ListNode> queue=new PriorityQueue<>(lists.length, new.

public ListNode reverseKGroup(ListNode head, int k){ ListNode res=new ListNode(0); res.next=head; ListNode pre=res; ListNode end=res; while(end!=null){ for(int i=0;i<k&&end!=null;i++){ ...

TreeNode pre,head; public TreeNode Convert(TreeNode pRootOfTree) { dfs(pRootOfTree); return head; } public void dfs(TreeNode cur){ if(cur==null) return; dfs(cur.left); if(pre!=null) pre.right=cur; ...

思路：采用一边倒转链表一边遍历，倒转一半就可以和后一半对比了。倒转链表用双指针来实现，遍历用另外的双指针来遍历，遍历用的快慢指针可以保证slow最后是指向后半部分的第一个结点。最后根据fast是否为空可以判断出链表结点数的奇偶。public boolean isPalindrome(ListNode head){ if(head==null||head.next==null) return true; ListNode fast=head; Lis.

设置快慢指针，如果链表是环形的，一快一慢的两个指针在环中一定相遇。public boolean hasCycle(ListNode head){ ListNode fast=head; ListNode slow=head; while(fast!=null){ fast=fast.next; if(fast!=null){ fast=fast.next; .

public ListNode addTwoNumbers(ListNode l1, ListNode l2){ ListNode res=new ListNode(0); ListNode cur=res; int carry=0;//表示进位 while(l1!=null||l2!=null){ int sum=carry; if(l1!=null){ sum.

思路： 根据题目要求，缓存区有顺序之分，需要查找键在不在，如果缓存容量已满，要删掉最久没有访问的键值，每次访问都要把该键当作是第一个。也就是说需要的数据结构要做到查找、插入和删除都要快速才行。哈希表查找快，链表插入和删除快，因此需要哈希表与链表结合使用。Node的定义思路：同时因为每次插入删除都在链表的表首和表尾，为了保证速度采用双向链表，链表的每个结点可以指向前结点和后结点。DoubleList的定义思路：双向链表只负责插入和删除，删除有两种情况，一种是缓冲区没满，但访问的键值已经存在，所以先

力扣83：思路：利用双指针，fast遍历链表，slow指向所有去掉重复元素的链表，因为是1223->123，所以第一个结点一定保留，不用创建新的结点，slow和fast可以直接指向head。public ListNode deleteDuplicates(ListNode head){ if(head==null) return null; ListNode slow=head; ListNode fast=head; whil

复杂链表的复制方法一：哈希表public RandomListNode Clone(RandomListNode pHead) { Map<RandomListNode,RandomListNode> map=new HashMap<>(); RandomListNode node=pHead; while(node!=null){ map.put(node,new RandomListNode(nod

链表中倒数最后k个结点public ListNode FindKthToTail (ListNode pHead, int k){ if(pHead==null) return null; ListNode fast=pHead; ListNode slow=pHead; for(int i=0;i<k;i++){ if(fast==null) return null;//需要考虑k>链表个数的情况

链表中环的入口结点：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;

public ListNode getIntersectionNode(ListNode headA, ListNode headB){ ListNode A=headA; ListNode B=headB; while(A!=B){ A=A!=null?A.next:headB; B=B!=null?B.next:headA; } return A; }

剑指offer25 合并两个排序的链表方法一：递归public ListNode Merge(ListNode l1,ListNode l2) { if(l1==null||l2==null){ return l1!=null?l1:l2; } if(l1.val<=l2.val){ l1.next=Merge(l1.next,l2); return l1;//递归算法参考

方法一：递归import java.util.ArrayList;public class Solution { int[] res; int count=0; int i=0; public ArrayList<Integer> printListFromTailToHead(ListNode listNode) { ArrayList<Integer> list=new ArrayList<>();