LeetCode——23. 合并K个升序链表

题目描述

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

 

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
  1->4->5,
  1->3->4,
  2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

示例 2：

输入：lists = []
输出：[]

示例 3：

输入：lists = [[]]
输出：[]

 

提示：

• k == lists.length
• 0 <= k <= 10^4
• 0 <= lists[i].length <= 500
• -10^4 <= lists[i][j] <= 10^4
• lists[i] 按 升序 排列
• lists[i].length 的总和不超过 10^4

解题思路

优先队列实现：

1、将vector建立成小顶堆（要求升序），时间复杂度为O(n)，n为链表个数

2、从小顶堆中pick出顶部链表的head元素，并使用head->next顶替原本位置（优先队列的push），再重新维护小顶堆，时间复杂度为O(lg n)

3、堆顶链表pick空掉之后，将堆顶与堆的最后一个元素互换，并调整堆的size

4、重复pick行为，直到所有元素都被pick出来，此处时间复杂度为 O(m * lg n)，m为总元素个数，n为链表个数

5、总体时间复杂度为 O(n) + O(m * lg n)，其中m >= n恒成立，故而时间复杂度为O(m * lg n)

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
#define PARENT(i) (((i + 1) >> 1) - 1)
#define LEFT(i) (((i + 1) << 1) - 1)
#define RIGHT(i) ((i + 1) << 1)
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        for (int i = 0; i < lists.size(); i++) {
            if (lists[i] == NULL) {
                lists.erase(lists.begin() + i);
                i--;
            }
        }
        if (lists.size() == 0)
            return NULL;
        if (lists.size() == 1)
            return lists[0];
        build_min_heap(lists);
        ListNode *head = NULL, *cur = NULL, *tmp = NULL;
        cur = pick_node(lists);
        head = cur;
        while(cur) {
            tmp = pick_node(lists);
            cur->next = tmp;
            cur = tmp;
        }
        return head;
    }
    
    void heapify(int pos, vector<ListNode*>& lists) {
        //cout << __func__ << " pos: " << pos << endl;
        if (pos < 0 || pos >= lists.size()) {
            cout << "unexpected pos:" << pos << endl;
            return;
        }
        if (lists.size() == 0 || lists.size() == 1)
            return;
        
        if (lists[pos] == NULL) {
            lists[pos] = lists.back();
            lists.pop_back();
            return heapify(pos, lists);
        }
        int min = lists[pos]->val;
        ListNode* tmp = lists[pos];
        int min_pos = pos;
        if (LEFT(pos) < lists.size() && min > lists[LEFT(pos)]->val) {
            min = lists[LEFT(pos)]->val;
            min_pos = LEFT(pos);
        }
        if (RIGHT(pos) < lists.size() && min > lists[RIGHT(pos)]->val) {
            min = lists[RIGHT(pos)]->val;
            min_pos = RIGHT(pos);
        }
        if (min_pos != pos) {
            lists[pos] = lists[min_pos];
            lists[min_pos] = tmp;
            heapify(min_pos, lists);
        }
    }
    void build_min_heap(vector<ListNode*>& lists) {
        //cout << __func__ << endl;
        if (lists.size() == 1) {
            return;
        }
        for (int pos = PARENT(lists.size() - 1); pos >= 0; pos--) {
            heapify(pos, lists);
        }
        return;
    }
    ListNode* pick_node(vector<ListNode*>& lists) {
        //cout << __func__ << endl;
        if (lists.size() == 0)
            return NULL;
        ListNode *tmp = lists[0];
        if (tmp == NULL) {
            return tmp;
        }
        lists[0] = tmp->next;
        heapify(0, lists);
        return tmp;
    }
};