Leetcode 题解系列（四）

23. Merge k Sorted Lists

题目要求

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

题目分析

1. 暴力解法

每一次遍历K个列表，取得最大的元素并进行归并。

ListNode* mergeKLists(vector<ListNode*>& lists) {
  bool completed = false;
  ListNode *ret = nullptr, *cur = nullptr;
  while (!completed) {
    int index, max = 0;
    completed = true;
    for (int i = 0; i < lists.size(); ++i) {
      if (lists[i] != nullptr) {
        completed = false;
      } else {
        continue;
      }
      if (lists[i]->val > max) {
        max = lists[i]->val;
        index = i;
      }
    }
    if (cur == nullptr) {
      ret = cur = lists[index];
    } else {
      cur->next = lists[index];
      cur = cur->next;
    }
    lists[index] = lists[index]->next;
  }
  return ret;
}

2. 使用堆进行加速

上述的方法需要进行N次的遍历，其中N为元素总数，故复杂度为$O(N^2)$。使用堆进行维护，可以使得获取最大值的复杂度为$O(1)$ + $O(log(K))$（取值与维护）。那么总的复杂度变为$O(Nlog(K))$

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *   int val;
 *   ListNode *next;
 *   ListNode(int x) : val(x), next(NULL) {}
 * };
 */
#include <queue>
struct ListCompare {
  bool operator() (const ListNode* lhs, const ListNode* rhs) {
    return lhs->val > rhs->val;
  }
};
using pq = std::priority_queue<ListNode*, vector<ListNode*>, ListCompare>;
class Solution {
public:
  ListNode* mergeKLists(vector<ListNode*>& lists) {
    pq queue;
    for (auto node : lists) {
      if (node != nullptr) {
        queue.push(node);
      }
    }
    ListNode* ret = nullptr, *cur = nullptr;
    while (!queue.empty()) {
      auto one = queue.top();
      queue.pop();
      if (cur == nullptr) {
        ret = cur = one;
      } else {
        cur->next = one;
        cur = cur->next;
      }
      one = one->next;
      if (one != nullptr) queue.push(one);
    }
    return ret;
  }
};

3. 使用分治的方法进行归并

对K个待归并的子链表进行分治归并，可以降低复杂度。