Merge k Sorted Lists leetcode java

题目:

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

题解:

Merge k sorted linked list就是merge 2 sorted linked list的变形题。

而且我们很自然的就想到了经典的Merge Sort,只不过那个是对数组进行sort。而不同的地方,仅仅是Merge两个list的操作不同。

这里来复习一下Merge Sort(对于数组操作),参考Wikipedia:

归并操作(merge),也叫归并算法,指的是将两个已经排序的序列合并成一个序列的操作。归并排序算法依赖归并操作。

归并操作的过程如下:

  1. 申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列
  2. 设定两个指针,最初位置分别为两个已经排序序列的起始位置
  3. 比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置
  4. 重复步骤3直到某一指针到达序列尾
  5. 将另一序列剩下的所有元素直接复制到合并序列尾
最差時間複雜度
最優時間複雜度
平均時間複雜度
最差空間複雜度

Merge Sort 对数组操作的Java代码为:

1 public int[] mergeSort(int[] arr){
 2     if(arr.length<2||arr == null)
 3         return arr;
 4     
 5     MSort(arr,0,arr.length-1);
 6 }
 7 
 8 public int[] MSort(int[] arr, int low, int high){
 9         if(low < high){
10                 int mid = (low+high)/2;
11                 int[] left = MSort(arr,low,mid);
12                 int[] right = MSort(arr,mid+1,high);
13                 return mergeTwoList(left,right);
14           }  
15 }
16 
17 
18 public int[] mergeTwoList(int[] A, int[] B) {
19     int[] C = new int[A.length + B.length];
20     int k = 0;
21     int i = 0;
22     int j = 0;
23     while(i < A.length && j < B.length) {
24         if (A[i] < B[j])
25             C[k++] = A[i++];
26         else
27             C[k++] = B[j++];
28     }
29     while (i < A.length) 
30         C[k++] = A[i++];
31     while (j < B.length) 
32         C[k++] = B[j++];
33     return C;
34 }

下面就是这道题的解法,跟上面的方法一样一样的,就是在mergeTwoList时候是对linkedlist做,套用Merge 2 sorted list解法即可,代码如下:

1     public ListNode mergeKLists(ArrayList<ListNode> lists) {  
 2         if(lists==null || lists.size()==0)  
 3             return null;  
 4         return MSort(lists,0,lists.size()-1);  
 5     }  
 6     
 7     public ListNode MSort(ArrayList<ListNode> lists, int low, int high){  
 8         if(low < high){  
 9             int mid = (low+high)/2;
10             ListNode leftlist = MSort(lists,low,mid);
11             ListNode rightlist = MSort(lists,mid+1,high);
12             return mergeTwoLists(leftlist,rightlist);  
13         }  
14         return lists.get(low);  
15     }
16 
17 
18     public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
19             if(l1==null)
20                 return l2;
21             if(l2==null)
22                 return l1;
23                 
24             ListNode l3;
25             if(l1.val<l2.val){
26                 l3 = l1;
27                 l1 = l1.next;
28             }else{
29                 l3 = l2;
30                 l2 = l2.next;
31             }
32             
33             ListNode fakehead = new ListNode(-1);
34             fakehead.next = l3;
35             while(l1!=null&&l2!=null){
36                 if(l1.val<l2.val){
37                     l3.next = l1;
38                     l3 = l3.next;
39                     l1 = l1.next;
40                 }else{
41                     l3.next = l2;
42                     l3 = l3.next;
43                     l2 = l2.next;
44                 }
45             }
46             
47             if(l1!=null)
48                 l3.next = l1;
49             if(l2!=null)
50                 l3.next = l2;
51             return fakehead.next;
52         }

更多Mergesort的讲法请参考:http://www.cs.princeton.edu/courses/archive/spr07/cos226/lectures/04MergeQuick.pdf

讲的挺好的

Merge k Sorted Lists leetcode java

时间: 2024-10-17 13:36:08

Merge k Sorted Lists leetcode java的相关文章

Merge Two Sorted Lists leetcode java

题目: Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists. 题解: 这道题是链表操作题,题解方法很直观. 首先,进行边界条件判断,如果任一一个表是空表,就返回另外一个表. 然后,对于新表选取第一个node,选择两个表表头最小的那个作为新表表头,指针后挪. 然后同时遍历

23. Merge k Sorted Lists - LeetCode

Question 23.?Merge k Sorted Lists Solution 题目大意:合并链表数组(每个链表中的元素是有序的),要求合并后的链表也是有序的 思路:遍历链表数组,每次取最小节点 Java实现: public ListNode mergeKLists(ListNode[] lists) { ListNode preHead = new ListNode(0); ListNode minNode = getMinNode(lists); ListNode tmpNode =

Merge K Sorted Lists -- LeetCode

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. 思路:构建一个大小为K的小顶堆.每次从堆顶取走一个元素后,都将这个元素所属的链表中下一个元素加入堆中.若没有下一个元素则不添加.该过程一直持续到堆空位置.时间复杂度O(nlogk). 用优先队列实现: 用优先队列实现的声明如下: priority_queue<元素类型, 该类型的容器(如vector<

23. Merge k Sorted Lists via Java

有序列表merge核心思想-->谁小就选谁加入结果 所以这道题的最核心问题也就找到了,就是要找到任意时刻的最小元素.所以需要维持一个数据结构,随时返回其中最小的元素,也就是最堆 然后这道题的难点就变成了写最小堆的comparator 下方代码中有两种我比较喜欢的方式 class Solution { public ListNode mergeKLists(ListNode[] lists) { if(lists==null || lists.length==0){ return null; }

【leetcode刷题笔记】Merge k Sorted Lists

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. 题解:最开始用了最naive的方法,每次在k个链表头中找出最小的元素,插入到新链表中.结果果断TLE了. 分析一下,如果这样做,每取出一个节点,要遍历k个链表一次,假设k个链表一共有n个节点,那么就需要O(nk)的时间复杂度. 参考网上的代码,找到了用最小堆的方法.维护一个大小为k的最小堆,存放当前k

[LeetCode] 023. Merge k Sorted Lists (Hard) (C++/Python)

索引:[LeetCode] Leetcode 题解索引 (C++/Java/Python/Sql) Github: https://github.com/illuz/leetcode 023. Merge k Sorted Lists (Hard) 链接: 题目:https://oj.leetcode.com/problems/merge-k-sorted-lists/ 代码(github):https://github.com/illuz/leetcode 题意: 和 021. Merge T

leetcode 刷题之路 93 Merge k Sorted Lists

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. 将k个有序链表合并成一个有序链表. 思路,之前做过两个有序链表的合并操作,对于k个链表,我们最先想到的就是能不能转化为我们熟悉的两个链表的合并,可以我们先将k个链表分为两部分,先对这两部分完成链表的有序合并操作,再对合并得到的两个链表进行合并,这是一个递归性质的描述,采用递归很容易实现这个程序,和数组

[leetcode]Merge k Sorted Lists @ Python

原题地址:https://oj.leetcode.com/problems/merge-k-sorted-lists/ 题意:Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. 解题思路:归并k个已经排好序的链表.使用堆这一数据结构,首先将每条链表的头节点进入堆中,然后将最小的弹出,并将最小的节点这条链表的下一个节点入堆,依次类推,最终形成的链表就是归

LeetCode: Merge k Sorted Lists [022]

[题目] Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. [题意] 合并K个有序链表 [思路] 归并 [代码] /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), n