合并K个排序链表

      合并两个有序链表前面已经说了，有迭代和递归二种方式，那如果合并K个呢，力扣说了3中方式，下面我们来看一下。

      1.顺序合并，看下代码

class Solution {
public:
	//合并两个链表
    ListNode* mergeTwoLists(ListNode *a, ListNode *b) {
        if ((!a) || (!b)) return a ? a : b;
        ListNode head, *tail = &head, *aPtr = a, *bPtr = b;
        while (aPtr && bPtr) {
            if (aPtr->val < bPtr->val) {
                tail->next = aPtr; aPtr = aPtr->next;
            } else {
                tail->next = bPtr; bPtr = bPtr->next;
            }
            tail = tail->next;
        }
        tail->next = (aPtr ? aPtr : bPtr);
        return head.next;
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode *ans = nullptr;
		//利用for循环依次合并
        for (size_t i = 0; i < lists.size(); ++i) {
            ans = mergeTwoLists(ans, lists[i]);
        }
        return ans;
    }
};

 这就是前面的迭代方法。

时间复杂度：O(k^2 * n)，k为链表的个数，n为链表最长的长度

空间复杂度：没有用到额外空间，则为O(1)

2.分治合并

class Solution {
public:
	//迭代的方式合并两个链表
    ListNode* mergeTwoLists(ListNode *a, ListNode *b) {
        if ((!a) || (!b)) return a ? a : b;
        ListNode head, *tail = &head, *aPtr = a, *bPtr = b;
        while (aPtr && bPtr) {
            if (aPtr->val < bPtr->val) {
                tail->next = aPtr; aPtr = aPtr->next;
            } else {
                tail->next = bPtr; bPtr = bPtr->next;
            }
            tail = tail->next;
        }
        tail->next = (aPtr ? aPtr : bPtr);
        return head.next;
    }

    //归并排序的思想，先两两合并最后在一起合并，用到了递归
    ListNode* merge(vector <ListNode*> &lists, int l, int r) {
        if (l == r) return lists[l];
        if (l > r) return nullptr;
        int mid = (l + r) >> 1;
        return mergeTwoLists(merge(lists, l, mid), merge(lists, mid + 1, r));
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        return merge(lists, 0, lists.size() - 1);
    }
};

先数组中的链表两两进行合并，最后在一起合并。

时间复杂度：O(kn×logk)

空间复杂度：O(logk) 空间代价的栈空间

3.使用优先队列进行合并，先看代码 

        优先队列：在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除

        最大优先队列，无论入队顺序，当前最大的元素优先出队

        最小优先队列，无论入队顺序，当前最小的元素优先出队

        大顶堆：每个结点的值都大于或等于其左右孩子结点的值

        小顶堆：每个结点的值都小于或等于其左右孩子结点的值

        优先队列的底层就是用二叉堆实现

        top 访问队头元素

        empty 队列是否为空

        size 返回队列内元素个数

        push 插入元素到队尾 (并排序)

        emplace 原地构造一个元素并插入队列

        pop 弹出队头元素

        swap 交换内容

class Solution {
public:
    struct Status {
        int val;
        ListNode *ptr;
        bool operator < (const Status &rhs) const {
            return val > rhs.val;
        }
    };

	//优先队列
    priority_queue <Status> q;

    //没有头结点
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        for (auto node: lists) {
			//将每个首节点和和第一个节点的值插入到优先队列
            if (node) q.push({node->val, node});
        }
		
        ListNode head, *tail = &head;
		
        while (!q.empty()) {
            auto f = q.top(); q.pop();
            tail->next = f.ptr; 
            tail = tail->next;
			//将next压入堆
            if (f.ptr->next) q.push({f.ptr->next->val, f.ptr->next});
        }
        return head.next;
    }
};

优先队列还是挺好用

 

 

代码地址：https://leetcode-cn.com/problems/merge-k-sorted-lists/solution/he-bing-kge-pai-xu-lian-biao-by-leetcode-solutio-2/