【LeetCode】23. Merge k Sorted Lists 基于Java的解法

23. Merge k Sorted Lists

Total Accepted: 88102 Total Submissions: 372066 Difficulty: Hard

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

【题意】

将K个已经排序的链表合并成一个排序的链表，分析并描述所用算法的复杂度。

【分析】

解法一：基于“二分”思想的归并排序

     初见之下，最容易想到的方法是“归并排序”（Merging Sort）：将两个或两个以上的有序表组合成一个新的有序表，无论是顺序存储结构还是链式存储结构，对于任何两个长度分别为m和n的有序表，其组合都可在O(m+n)的时间复杂度量级上完成。对于K个有序表，假设共有N个元素，且这些有序表初始状态都不为空，每个有序表平均拥有N/K个元素。最常用的方法是采用“二分”的思想进行两两合并：第一轮循环，有序表lists[0]与lists[(K+1)/2]，lists[1]与lists[(K+1)/2+1]，lists[2]与lists[(K+1)/2+2]....，lists[K/2-1]与lists[K-1]。这样K个有序表就被组合成了K/2个有序表；第二轮循环后将减少为K/4个有序表；直到组合成一个具有N个元素的有序表。总的时间复杂度：O(NKlogK)。

解法二：基于优先级队列的“堆排序”

   堆(Heap)的定义如下：n个元素的序列{k1,k2,k3,...,kn}当且仅当满足下列关系时，称为堆，

   其中前者称为最小堆，后者称为最大堆。在Java中，堆是一种可以自我调整的二叉树，对于最小堆来说，对树执行删除和添加操作，可以让最小元素移动到根节点。在Java中，优先级队列（Priority Queue）便采用了“堆”这种数据结构，PriorityQueue是一个泛型类，它可以保存实现了Comparable接口的类对象，也可以保存在构造器中提供比较器的对象（优先级队列实现排序中也需要比较）。

     基于优先级队列，我们可以将K个链表的头结点全部添加到队列，由于优先级队列采用了最小堆数据结构，堆顶为队列的最小元素，我们将其取出添加到结果链表中，取出元素对应的链表下移一个节点，并将这个节点添加到优先级队列中；然后我们继续取出堆顶元素，...，直到优先级队列为空，那么其中所有元素取尽，K个链表的元素已经全部排序到结果链表。

【程序】

 一、基于“二分”思想的归并排序（Java实现）

/** * Definition for singly-linked list. * public class ListNode { *     int val; *     ListNode next; *     ListNode(int x) { val = x; } * } */class Solution{public ListNode mergeKLists(ListNode[] lists){int len=lists.length;if(lists==null||len==0)return null;if(len==1)return lists[0];while(len>1)//基于“二分”思想进行链表的两两组合{int mid=(len+1)/2;//二分    for(int i=0;i<len/2;i++)    {    lists[i]=mergeTwoLists(lists[i],lists[i+mid]);    }    len=mid;}return lists[0];}//有序链表的组合，L1和L2为头结点，归并排序的核心思想public ListNode mergeTwoLists(ListNode L1,ListNode L2){if(L1==null)return L2;if(L2==null)return L1;ListNode head=new ListNode(0);//保存结果的链表，头结点初始化ListNode phead=head;while(L1!=null&&L2!=null)//两个链表归并排序{if(L1.val <=L2.val){phead.next=L1;//接入结果链表phead=phead.next;//移动指针L1=L1.next;}else{phead.next=L2;phead=phead.next;L2=L2.next;}}if(L1!=null)phead.next=L1;elsephead.next=L2;return head.next;//初始化的第一个节点不属于结果}}

运行结果：

 二、基于优先级队列的“堆排序”（Java实现）

class ListNode implements Comparable<ListNode>{int value;ListNode next;ListNode(int val){value=val;}public int compareTo(ListNode other){return value-other.value;}}

//用优先级队列实现组合排序，其中优先级队列采用的数据结构为“最小堆”class Solution{public ListNode mergeKLists(ListNode[] lists){if(lists==null||lists.length==0)return null;if(lists.length==1)return lists[0]; PriorityQueue<ListNode> PQ=new PriorityQueue<ListNode>();ListNode head=new ListNode(0);ListNode phead=head;for(ListNode list:lists){if(list!=null)PQ.offer(list);}while(!PQ.isEmpty()){ListNode temp=PQ.poll();phead.next=temp;phead=phead.next;if(temp.next!=null)PQ.offer(temp.next);}return head.next;}}

运行结果：