合并K个有序链表

合并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) {
        //边界判断 异常判断
        if(lists==null||lists.length==0) return null;
        //用List实现堆 索引0不放元素 index的左孩子为2*index 右孩子为2*index+1
        List<ListNode> heap=new ArrayList<>();
        ListNode head=null;
        ListNode s=null;
        heap.add(null);
        //先将K个链表的第一个节点放入堆中 堆得大小≤k 因为如果有null 则不放进去
        for(int i=0;i<lists.length;i++)
            if(lists[i]!=null)
                heap.add(lists[i]);
        //从n/2处 向上维护堆得性质
        for(int i=(heap.size()-1)/2;i>=1;i--)
            protectedHeap(heap,i);
        //每次从堆顶拿走最小的节点
        //如果这个节点的下一个节点为null 如果这个节点的下一个节点不为null 该怎么办？自行脑补，我打字很难表达
        //维护堆得性质 
        while(heap.size()>1){
            ListNode temp=heap.get(1);
            if(temp.next==null){
                heap.set(1,heap.get(heap.size()-1));
                heap.remove(heap.size()-1);
            }else{
                heap.set(1,temp.next);
            }
            protectedHeap(heap,1);
            if(head==null){
                head=temp;
                s=head;
            }else{
                s.next=temp;
                s=s.next;
            }
            s.next=null;
        }
        return head;
    }
    //维护堆得性质 方法如下
    public void protectedHeap(List<ListNode> heap,int index){
        if(2*index>=heap.size()) return ;
        if(2*index+1>=heap.size()){
            if(heap.get(2*index).val>=heap.get(index).val)
                return;
            else{
                ListNode temp=heap.get(2*index);
                heap.set(2*index,heap.get(index));
                heap.set(index,temp);
                protectedHeap(heap,2*index);
            }
        }else{
             int temp=heap.get(2*index).val<heap.get(2*index+1).val?2*index:2*index+1;
             if(heap.get(temp).val<heap.get(index).val){
                 ListNode node=heap.get(temp);
                 heap.set(temp,heap.get(index));
                 heap.set(index,node);
                 protectedHeap(heap,temp);
             }else{
                 return;
             }
        }
    }
}