腾讯//合并K个排序链表

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

示例:

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

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        ListNode result = new ListNode(0);
        ListNode point = result;
        List<Integer> list = new ArrayList<Integer>();
        for(ListNode node:lists){
            while(node != null){
                list.add(node.val);
                node = node.next;
            }
        }
        Collections.sort(list);
        for(int x:list){
            point.next = new ListNode(x);
            point = point.next;
        }
        return result.next;
    }
}

找寻出K个链表中的最小节点，并将其从K个链表集中剔除，再将其添加到新的链表中，直到K个链表都为空为止。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        ListNode result = new ListNode(0);
        ListNode point = result;
        while(true){
            int min_val = Integer.MAX_VALUE;
            int position = -1;
            for(int i = 0; i < lists.length; i++){
                if(lists[i] != null){
                    if(lists[i].val < min_val){
                        min_val = lists[i].val;
                        position = i;
                    }
                }
            }
            if(min_val == Integer.MAX_VALUE)
                break;
            point.next = new ListNode(min_val);
            point = point.next;
            lists[position] = lists[position].next;
        }
        return result.next;
    }
}

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
        public ListNode mergeKLists(ListNode[] lists){
        ListNode result = new ListNode(0);
        ListNode point = result;
        PriorityQueue<ListNode> q = new PriorityQueue<>(valComparator);
        for(ListNode node:lists){
            if(node!=null){
                q.add(node);
            }
        }
        while(!q.isEmpty()){
            ListNode current_node = q.poll();
            point.next = new ListNode(current_node.val);
            point = point.next;
            current_node = current_node.next;
            if(current_node!=null){
                q.add(current_node);
            }
        }
        return result.next;
    }

    private static Comparator<ListNode> valComparator = new Comparator<ListNode>() {
        @Override
        public int compare(ListNode o1, ListNode o2) {
            return (int)(o1.val - o2.val);
        }
    };

}

 本次题目是“合并K个排序链表”，其实我们可以从题目合并两个有序链表中获得灵感，将K个链表两两合并(merge lists onr by one)，得到最终结果。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    private ListNode mergeTwoLists(ListNode l1, ListNode l2){
        if(l1 == null) return l2;
        if(l2 == null) return l1;
        if(l1.val < l2.val){
            l1.next = mergeTwoLists(l1.next,l2);
            return l1;
        }else{
            l2.next = mergeTwoLists(l1,l2.next);
            return l2;
        }
    }
    public ListNode mergeKLists(ListNode[] lists) {
        ListNode head = new ListNode(0);
        ListNode point = head;
        for(ListNode node:lists){
            point.next = mergeTwoLists(point.next,node);
        }
        return head.next;
    }
}

 将K个链表分成两两一组，使用方法：合并两个有序链表，将其合并，再将结果两两分组，合并，直到得到最终结果。

class Solution {
    private ListNode mergeTwoLists(ListNode l1, ListNode l2){
        if(l1==null)return l2;
        if(l2==null)return l1;
        if(l1.val<l2.val){
            l1.next=mergeTwoLists(l1.next, l2);
            return l1;
        }else{
            l2.next=mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
    public ListNode mergeKLists(ListNode[] lists) {
        if(lists==null||lists.length==0)return null;
        int length = lists.length;
        int interval = 1;
        while (interval < length) {
            for (int i = 0; i < length - interval; i += interval * 2) {
                lists[i] = mergeTwoLists(lists[i], lists[i + interval]);
            }
            interval *= 2;
        }
        return lists[0];
    }
}

C++:

方法一：

struct ListNode
{
    int val;
    ListNode* next;
    ListNode(int x):val(x),next(NULL) {}
};

class Solution
{
public:
    ListNode* mergeKLists(vector<ListNode*>&lists)
    {
        ListNode* result = new ListNode(0);
        ListNode* point = result;
        list<int> l = list<int>();
        for(int i=0; i<lists.size(); i++)
        {
            while(lists[i])
            {
                l.push_back(lists[i]->val);
                lists[i]=lists[i]->next;
            }
        }
        l.sort();
        for(list<int>::iterator it = l.begin(); it!=l.end(); it++)
        {
            point->next=new ListNode(*it);
            point=point->next;
        }

        return result->next;
    }
};

方法二：

ListNode* mergeKLists(vector<ListNode*>&lists)
    {
        ListNode* result = new ListNode(0);
        ListNode* point = result;
        while(true)
        {
            int min_val = INT_MAX;
            int position = -1;
            for(int i=0;i<lists.size();i++)
            {
                if(lists[i]!=NULL)
                {
                    if(lists[i]->val<min_val)
                    {
                        min_val = lists[i]->val;
                        position = i;
                    }
                }
            }
            if(min_val==INT_MAX)
                break;
            point->next = new ListNode(min_val);
            point = point->next;
            lists[position] = lists[position]->next;
        }
        return result->next;
    }

class myCompare
{
public:
    bool operator()(ListNode* node_1,ListNode* node_2)const
    {
        return node_1->val>node_2->val;
    }
};

class Solution
{
public:
    ListNode* mergeKLists(vector<ListNode*>&lists)
    {
        ListNode* head = new ListNode(0);
        ListNode* point = head;
        priority_queue<ListNode*,vector<ListNode*>,myCompare>q;
        for(int i=0;i<lists.size();i++)
        {
            if(lists[i]!=NULL)
                q.push(lists[i]);
        }
        while(!q.empty())
        {
            ListNode* current_node=q.top();
            q.pop();
            point->next=new ListNode(current_node->val);
            point=point->next;
            current_node=current_node->next;
            if(current_node!=NULL)
                q.push(current_node);
        }
        return head->next;
    }
};

    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2)
    {
        if(l1==NULL)return l2;
        if(l2==NULL)return l1;
        if(l1->val<l2->val)
        {
            l1->next=mergeTwoLists(l1->next,l2);
            return l1;
        }
        else
        {
            l2->next=mergeTwoLists(l1,l2->next);
            return l2;
        }
    }

    ListNode* mergeKLists(vector<ListNode*>&lists)
    {
        ListNode* head = new ListNode(0);
        ListNode* point = head;
        for(int i=0; i<lists.size(); i++)
            point->next=mergeTwoLists(point->next,lists[i]);
        return head->next;
    }

 ListNode* mergeTwoLists(ListNode* l1, ListNode* l2)
    {
        if(l1==NULL)return l2;
        if(l2==NULL)return l1;
        if(l1->val<l2->val)
        {
            l1->next=mergeTwoLists(l1->next,l2);
            return l1;
        }
        else
        {
            l2->next=mergeTwoLists(l1,l2->next);
            return l2;
        }
    }

    ListNode* mergeKLists(vector<ListNode*>&lists)
    {
        if(lists.size()==0)return NULL;
        int length=lists.size();
        int interval=1;
        while(interval<length)
        {
            for(int i=0; i<length-interval; i+=interval*2)
            {
                lists[i]=mergeTwoLists(lists[i],lists[i+interval]);
            }
            interval*=2;
        }
        return lists[0];
    }