[合并k个升序链表]（力扣）

题意

给你一个链表数组，每个链表都已经按升序排列，请你将所有链表合并到一个升序链表中，返回合并后的链表。

样例

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

思路

其实给的解释就已经告诉我们应该怎么做了—>分治
加入一共有5个链表，先将1-2、3-4两两合并，得到的结果是(12)、(34)、5三个链表，在将前两个进行合并，得到(1234)、5两个链表，在进行最后的合并。
时间复杂度：O(nlog)

class Solution
{
public:
	ListNode* mergerLists(ListNode* a, ListNode* b)
	{
		if ((!a) || (!b)) retrurn a ? a : b;
		ListNode head, *tail = &head, *pa = a, *pb = b;
		while (pa && pb)
		{
			if (pa->val < pb->val) tail->next = pa, pa = pa->next;
			else tail->next = pb, pb = pb->next;
			tail = tail->next;
		}
		tail->next = (pa ? pa : pb);
		return head.next;
	}
	
	ListNOde* merge(vector<ListNode*> &lists, int l, int r)
	{
		if (l == r) return lsits[l];
		if (l > r) return nullptr;
		
		int mid = (l + r) >> 1;
		return mergerLists(merge(lists, l, mid), merge(lists, mid + 1, r));
	}

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

力扣上的方法三：使用优先队列合并：
时间复杂度是一个常数。
首先在一个优先队列中，默认是按照从小到大排序的，默认的优先队列是一个大顶堆，队头元素最大。
那么在这里，我们将每个链表的首元素放进优先队列中，放进去之后，每个元素的大小我们让它从小到大进行排序，但是这里我们虽然有了从小到达排序的值，但是对于每个链表中的其他元素该如何去放位置呢？所以这里我们使用一个结构体来存储两个变量：1.值(val)， 2.该节点的指针(ptr)。

struct Status
{
	int val;
	ListNode *ptr;
	// 这里我们要使优先队列中的值是从小到大的顺序进行排序，默认是大根堆。
	bool operator < (const Status& rhs) const { return val > rhs.val; }
};

那么我们在遍历优先队列的时候，只有当前值它的后面还有值，那么我们将这个值放入优先队列里面，队列里面会自动将这些值进行排序。

class Soulution
{
public:
	struct Status
	{
		int val;
		ListNode* ptr;
		bool operator < (const Status & rhs) const { return val > ths.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;
			if (f.ptr->next) q.push({f.ptr->val, f.ptr->next});
		}
	};
};