LeetCode 23：合并k个排序链表

题目描述

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

示例:

输入:
[
1->4->5,
1->3->4,
2->6
]
输出: 1->1->2->3->4->4->5->6

解题思路

借助堆的结构，将k个排序链表依次插入小顶堆中，注意插入的每个元素都是一个链表，不是单一的某个节点！！！之后先构建一个头结点，然后借助一个指针，初始指向头结点，然后每次从小顶堆中弹出一个节点，依次连接在头结点后面，每次添加节点后，指针后移！如果弹出的是一个链表，除了将其头结点添加到连表外，还需将其余部分重新添加到小顶堆中！！！

代码实现

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

import java.util.Comparator;
import java.util.PriorityQueue;

class ListNode{
    int val;
    ListNode next;
    ListNode(int x){
        this.val=x;
    }
}
public class mergeLists {
    //合并k个排序链表
    public ListNode mergeKlists(ListNode[] lists){// acc:6ms 63%
        if (lists==null||lists.length==0){
            return null;
        }
        PriorityQueue<ListNode> queue = new PriorityQueue<>(lists.length, new Comparator<ListNode>() {
            @Override
            public int compare(ListNode o1, ListNode o2) {

                return o1.val-o2.val;
            }
        });

        ListNode dummy=new ListNode(0);
        ListNode p=dummy;
        for (ListNode node:lists){
            if (node!=null){
                queue.add(node);//遍历list将所有链表插入队列
            }
        }
        while (!queue.isEmpty()){
            p.next=queue.poll();//每次从队列中弹出最小的元素，然后添加在尾部
            p=p.next; //指针后移
            if (p.next!=null){ //如果弹出的是一个链表，
                              // 除了将其头部添加在新的链表尾部外，其余部分继续放入队列
                queue.add(p.next);
            }
        }
        return dummy.next;
    }

    public ListNode mergeKlists_1(ListNode[] lists) {// acc:4ms 76%
        if(lists.length == 0)
            return null;
        if(lists.length == 1)
            return lists[0];
        if(lists.length == 2){
            return mergeTwoLists(lists[0],lists[1]);
        }

        int mid = lists.length/2;
        ListNode[] l1 = new ListNode[mid];
        for(int i = 0; i < mid; i++){
            l1[i] = lists[i];
        }

        ListNode[] l2 = new ListNode[lists.length-mid];
        for(int i = mid,j=0; i < lists.length; i++,j++){
            l2[j] = lists[i];
        }

        return mergeTwoLists(mergeKlists(l1),mergeKlists(l2));

    }
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if (l1 == null) return l2;
        if (l2 == null) return l1;

        ListNode head = null;
        if (l1.val <= l2.val){
            head = l1;
            head.next = mergeTwoLists(l1.next, l2);
        } else {
            head = l2;
            head.next = mergeTwoLists(l1, l2.next);
        }
        return head;
    }


    public static void main(String[] args) {
        ListNode node1=new ListNode(1);
        ListNode node2=new ListNode(5);
        ListNode node3=new ListNode(3);
        ListNode node4=new ListNode(6);
        node1.next=node2;
        node2.next=null;
        node3.next=node4;
        node4.next=null;

        ListNode[] list = {node1,node3};
        mergeLists test=new mergeLists();
        ListNode p=test.mergeKlists_1(list);
        System.out.println(p.val+","+p.next.val);
    }

}

总结

本题来源于Leetcode中 归属于堆类型题目。
同许多在算法道路上不断前行的人一样，不断练习，修炼自己！
如有博客中存在的疑问或者建议，可以在下方留言一起交流，感谢各位！

觉得本博客有用的客官，可以给个赞鼓励下！ 嘿嘿