Leetcode 23 合并K个排序链表 Merge k Sorted Lists

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

Example:

Input:
[
  1->4->5,
  1->3->4,
  2->6
]
Output: 1->1->2->3->4->4->5->6

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-k-sorted-lists
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

方法一：暴力

暴力就是把所有的链表中的元素都放入数组中，使用sort进行排序，再把他们重新连成一个链表。看起来有点傻，但是跑起来效果意外的好。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        int i;
        int size = lists.size();
        if (size == 0) return NULL;
        int store[10000];
        int k = 0;
        ListNode* q;
        for (i = 0; i < size; i++) {
            for (q=lists[i]; q!=NULL; q=q->next) {
                store[k] = q->val;
                k++;
            }
        }
        sort(store, store+k);
        ListNode* start = new ListNode(0);
        ListNode* p = start;
        for (i = 0; i < k; i++) {
            p->next = new ListNode(store[i]);
            p = p->next;
        }
        return start->next;
    }
};

 

方法二：每次合并2个

该方法循环n-1次，每次将第i个链表合并到当前结果链表中。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        int i,j;
        int size=lists.size();
        if(size==0) return NULL;
        ListNode * start= lists[0];
        for(i=1;i<size;i++){
            start=mergeTwoLists(start, lists[i]);
        }
        return start;
    }
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if (l1==NULL) return l2;
        else if(l2==NULL) return l1;
        else if(l1->val<=l2->val) {
            l1->next = mergeTwoLists(l1->next,l2);
            return l1;
        }else{
            l2->next = mergeTwoLists(l2->next,l1);
            return l2;
        }
    }
};

方法三：优先队列

首先是优先队列的用法：

priority_queue<int, vector<int>, greater<int> >p;

然后常用的函数有push、pop、top、empty、size等

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        int i;
        int size = lists.size();
        if (size == 0) return NULL;
        priority_queue<int, vector<int>, greater<int>> que;
        ListNode* q;
        for (i = 0; i < size; i++) {
            q = lists[i];
            while (q != NULL) {
                que.push(q->val);
                q = q->next;
            }
        }
        ListNode* start = new ListNode(0);
        ListNode* p = start;
        int qsize = que.size();
        for (i = 0; i < qsize; i++) {
            p->next = new ListNode(que.top());
            p = p->next;
            que.pop();
        }
        return start->next;
    }
};