23_合并k个排序链表C++

方法一：简单方法.时间复杂度O(k^2N)，空间复杂度O(1)

class Solution {
public:
	ListNode* merge2List(ListNode* AList, ListNode* BList)
	{
		ListNode* mergehead,*mergetemp;
		mergehead = NULL;
		if (!AList&&!BList)
			return mergehead;
		if (!AList)
			return BList;
		if (!BList)
			return AList;
		if (AList->val <= BList->val)
		{
			mergetemp = AList;
			AList = AList->next;
		}
		else
		{
			mergetemp = BList;
			BList = BList->next;
		}
		mergehead = mergetemp;
		while (AList&&BList)
		{
			if (AList->val <= BList->val)
			{
				mergetemp->next = AList;
				mergetemp = mergetemp->next;
				AList = AList->next;
			}
			else
			{
				mergetemp->next = BList;
				mergetemp = mergetemp->next;
				BList = BList->next;
			}
		}
		if (AList)
			mergetemp->next = AList;
		if (BList)
			mergetemp->next = BList;
		return mergehead;
	}
	ListNode* mergeKLists(vector<ListNode*>& lists) {
		ListNode* anshead=NULL;
		if (lists.empty())
			return anshead;
		if (lists.begin() + 1 == lists.end())
		{
			anshead = *(lists.begin());
		}
		for (auto iter = lists.begin(); iter + 1 != lists.end(); ++iter)
		{
			if (iter == lists.begin())
			{
				ListNode* A = *iter;
				ListNode* B = *(iter + 1);
				anshead = merge2List(A, B);
			}
			else
			{
				ListNode* B = *(iter + 1);
				anshead = merge2List(anshead, B);
			}
		}
		return anshead;
	}
};

方法二：分治法。时间复杂度O(kn×logk)，空间复杂度：因为递归了logk次，需要用到O(logk)空间代价的栈空间

class Solution {
public:
	ListNode* merge2List(ListNode* AList, ListNode* BList)
	{
		ListNode* mergehead,*mergetemp;
		mergehead = NULL;
		if (!AList&&!BList)
			return mergehead;
		if (!AList)
			return BList;
		if (!BList)
			return AList;
		if (AList->val <= BList->val)
		{
			mergetemp = AList;
			AList = AList->next;
		}
		else
		{
			mergetemp = BList;
			BList = BList->next;
		}
		mergehead = mergetemp;
		while (AList&&BList)
		{
			if (AList->val <= BList->val)
			{
				mergetemp->next = AList;
				mergetemp = mergetemp->next;
				AList = AList->next;
			}
			else
			{
				mergetemp->next = BList;
				mergetemp = mergetemp->next;
				BList = BList->next;
			}
		}
		if (AList)
			mergetemp->next = AList;
		if (BList)
			mergetemp->next = BList;
		return mergehead;
	}
	ListNode* merge(vector<ListNode*>& lists, int left, int right)
	{
		if (left == right)
			return lists[left];
		if (left > right)//可能会出现mid+1>right
			return nullptr;
		int mid = (right + left)/2;
		return merge2List(merge(lists, left, mid), merge(lists, mid + 1, right));
	}
	ListNode* mergeKLists(vector<ListNode*>& lists) {
		ListNode* anshead=NULL;
		anshead = merge(lists, 0, lists.size() - 1);
		return anshead;
	}
};

方法三：使用优先队列。优先队列中元素不超过k个，优先队列由二叉堆实现，则插入和删除的时间代价为O(logk)。最多有kn个点，每个点都被插入删除一次，则时间复杂度为O(kn×logk)。空间复杂度为O(k).

class Solution {
public:
	struct Status
	{
		ListNode* head;
		int val;
		bool operator<(const Status& rhs)const
		{
			return val > rhs.val;//值越小优先级越高
		}
	};
	priority_queue<Status> q;
	ListNode* mergeKLists(vector<ListNode*>& lists) {
		ListNode* anshead,*anstail;
		anshead = nullptr;
		anstail = nullptr;
		for (auto node : lists)
		{
			if (node)
				q.push({ node,node->val });
		}
		if (!q.empty())
		{
			ListNode* temp;
			temp= q.top().head;
			q.pop();
			anstail = temp;
			if(temp->next)
			q.push({temp->next,temp->next->val});
		}
		anshead = anstail;
		while (!q.empty())
		{
			ListNode* temp;
			temp = q.top().head;
			q.pop();
			anstail->next = temp;
			anstail = anstail->next;
			if(temp->next)
			q.push({ temp->next,temp->next->val });
		}
		return anshead;
	}
};