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

思路

两两合并。

（0，          k/2）              -> 0)
（1，          k/2 + 1）          -> 1)
......
（k/2 - 1，    k/2 + k/2 - 1）    -> k/2 - 1)

如果k为奇数，则将最后一个链表挪到k/2的位置
继续进行下一轮，直到链表总数为1

代码

/**
 * 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) {
        if (lists.size() <= 0) {
            return 0;
        }
        while (lists.size() > 1) {
            for (int i = 0; i < lists.size() / 2; ++i) {
                lists[i] = MergeTwoLists(lists[i], lists[i + lists.size() / 2]);
            }
            if (lists.size() % 2 != 0) {
                lists[lists.size() / 2] = lists[lists.size() - 1];
            }
            lists.resize((lists.size() % 2 == 0) ? lists.size() / 2 : lists.size() / 2 + 1);
        }
        return lists[0];
    }
private:
    ListNode* MergeTwoLists(ListNode *list1, ListNode *list2) {
        if (list1 == 0) {
            return list2;
        }
        if (list2 == 0) {
            return list1;
        }
        
        ListNode *p1 = list1;
        ListNode *p2 = list2;
        ListNode dummyHead(-1);
        ListNode *tail = &dummyHead;
        while (p1 != 0 && p2 != 0) {
            if (p1->val < p2->val) {
                tail->next = p1;
                p1 = p1->next;
                tail = tail->next;
                tail->next = 0;
            } else {
                tail->next = p2;
                p2 = p2->next;
                tail = tail->next;
                tail->next = 0;
            }
        }
        if (p1 != 0) {
            tail->next = p1;
        }
        if (p2 != 0) {
            tail->next = p2;
        }
        return dummyHead.next;
    }
};

算法效率

每一轮都要遍历所有元素（剩余奇数个链表时少一个链表），每轮将链表总数减半，因此复杂度为O(nlgn)

Runtime: 20 ms, faster than 98.77% of C++ online submissions for Merge k Sorted Lists.
Memory Usage: 10.6 MB, less than 100.00% of C++ online submissions for Merge k Sorted Lists.