方法一
每次在每个列表中选一个最小值
定一个初始值 一开始只放k个值，开好空间
----Heapsort
在节点ListNode定义中，定义为节点为结构变量。
节点存储了两个变量：value 和 next。value 是这个节点的值，next 是指向下一节点的指针，当 next 为空指针时，这个节点是链表的最后一个节点。
注意注意val只代表当前指针的值，比如p->val表示p指针的指向的值；而p->next表示链表下一个节点，也是一个指针。
构造函数包含两个参数 _value 和 _next ，分别用来给节点赋值和指定下一节点
Java 1.5版本后就提供了一个具备了小根堆性质的数据结构也就是优先队列PriorityQueue。
----//PriorityQueue默认是一个小顶堆，然而可以通过传入自定义的Comparator函数来实现大顶堆。
实际上是一个堆（不指定Comparator时默认为最小堆）
队列既可以根据元素的自然顺序来排序，也可以根据 Comparator来设置排序规则。
队列的头是按指定排序方式的最小元素。如果多个元素都是最小值，则头是其中一个元素。
新建对象的时候可以指定一个初始容量，其容量会自动增加。
----关于dummy
1.由于不确定左右两个部分是否有点，两边分别需要建立一个dummy node
2.左右dummy和左右的tail。 注意：dummy是作为一个虚拟的头，用于返回时候用的。
对于左右两边分别建立一个leftTail pointer 和 rightTail pointer 分别记录当前两个list的尾巴。这样每次拿到一个新的点current，判断大小后可以直接加到相应的尾巴处。
3.对于右边部分的最后一个点，尾巴节点的next很可能不为空，所以要对其进行rightTail->next = null 的处理
九章代码：
//一般会限制你使用 priority node 因为太简单了
】package test.mergeSort;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
import test.mergeSort.ListNode;
/**
* public class ListNode {
int val;
ListNode next;
ListNode(int val) {
this.val = val;
this.next = null;
}
}
*
*
* @author Howard_Zhou
*
*/
public class Solution {
/**
* @param lists: a list of ListNode
* @return: The head of one sorted list.
*/
private Comparator<ListNode> ListNodeComparator = new Comparator<ListNode>() {
public int compare(ListNode left, ListNode right) {
if (left == null) {
return 1;
} else if (right == null) {
return -1;
}
return left.val - right.val;
}
};
public ListNode mergeKLists(List<ListNode> lists) {
if (lists == null || lists.size() == 0) {
return null;
}
Queue<ListNode> heap = new PriorityQueue<ListNode>(lists.size(), ListNodeComparator);
for (int i = 0; i < lists.size(); i++) {
if (lists.get(i) != null) {
//将每个小list的头添加到heap中，这些头添加进去后被排序了（通过heap的ListNodeComparator）
heap.add(lists.get(i));
}
}
//dummy没用，dummy.next指向新链表的头
ListNode dummy = new ListNode(0);
//tail是新指针
ListNode tail = dummy;
while (!heap.isEmpty()) {
//poll会把heap中的最小元素(head)取出并删除
ListNode head = heap.poll();
//构建新链表
tail.next = head;
tail = head;
if (head.next != null) {
//head所在的小list中如果有head.next就把它添加进heap,这样实现了排序
heap.add(head.next);
}
}
return dummy.next;
}
public static void main(String[] args) {
ListNode node1 = new ListNode(2);
ListNode node2 = new ListNode(4);
ListNode node3 = new ListNode(-1);
node1.next = node2;
List<ListNode> lists = new LinkedList<ListNode>();
lists.add(node1);
lists.add(node3);
Solution solution = new Solution();
ListNode mergeKLists = solution.mergeKLists(lists);
System.out.println(mergeKLists);
}
}
这个很暴力很复杂
方法2
可以从下往上 成对成对 像是二叉树从下到
public ListNode mergeKlists(List<ListNode> lists){
if(lists==null||lists.size()==0){
return null;
}
while (lists.size()>0){
List<ListNode> new_lists=new ArrayList<ListNode>();
for (int i=0;i+1<lists.size();i+=2){
ListNode merge_list=merge(lists.get(i),lists.get(i+1));
new_lists.add(merge_list);
}
if(lists.size%2==1){
new_lists.add(lists.get(lists.size()-1));
}
lists=new_lists;
}
return lists.get(0);
}
public ListNode merge(ListNode a,ListNode b){
ListNode dummy=new ListNode(0);
ListNode tail=dummy;
while(a!=null&&b!=null){
if(a.val<b.val){
tail.next=a;
a=a.next;
}else{
tail.next=b;
b=b.next;
}
tail=tail.next;
}
if(a!=null){
tail.next=a;
}else{
tail.next=b;
}
return dummy.next;
}
方法三 最重要的归并方法
public ListNode mergeKlists(List<ListNode> lists){
if(lists==null||lists.size()==0){
return null;
}
return mergeHelper(lists,0,lists.size()-1);
}
private ListNode mergeHelper(List<ListNode> lists, int start, int end){
if(start==end){
return lists.get(start);
}
int mid=start+(end-start)/2;
ListNode left=mergeHelper(lists,start,mid);
ListNode right=mergeHelper(lists,mid+1,end);
return mergeTwoLists(left,right);
}
private ListNode mergeTwoLists(ListNode List1,ListNode list2){
ListNode dummy=new ListNode(0);
ListNode tail=dummy;
while(list1!=null&&list2!=null){
if(list1.val<list2.val){
tail.next=list1;
list1=list1.next;
}else{
tail.next=list2;
list2=list2.next;
}
tail=tail.next;
}
if(list1!=null){
tail.next=list1;
}else{
tail.next=list2;
}
return dummy.next;
}
