leecode 解题总结：23 Merge k Sorted Lists

#include <iostream>
#include <stdio.h>
#include <vector>


using namespace std;
/*
问题:
Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
分析:
归并k个排序链表。这个怎么看上去像败者树。
暴力破解:假设每个链表长度为n,总的元素个数为n*k,每次遍历k个链表中最小值，时间复杂度为O(k)，一共需要遍历n*k个元素，
		 所以总的时间复杂度为O(n*k^2)
另一种方法：把该问题看成是对两个链表进行归并，那么可以采用类似分治的思想。
            例如把4个链表归并：先分成两组：1号链表和2号链表先归并得5号链表，3号链表和4号链表归并得6号链表。5号链表和6号链表归并的最终结果
			所以总的归并次数m= Log(2)(k) + Log(2^2)(k) + ... + Log(2^p)(k)
			由于两个链表排序的时间复杂度为O(n),共可以分成

输入:
4
2 3 3 2
1 5
3 5 8
0 6 9
2 10

3
2 3 3 2
1 5
3 5 8
0 6 9
输出:
0 1 2 3 5 5 6 8 9 10
0 1 3 5 5 6 8 9

关键：
1果然是k路归并排序采用分治方法
ListNode* merge(vector<ListNode*>& lists , int low , int high ,vector<ListNode*>& mergeLists )
{
	if(lists.empty() || low > high)
	{
		return NULL;
	}
	int size = lists.size();
	if(low < 0 || high < 0 || low >= size || high >= size)
	{
		return NULL;
	}
	//如果此时恰好只有一个链表，直接返回
	if(low == high)
	{
		return lists.at(low);
	}
	//如果此时有两个链表，就进行两个链表的排序处理
	else if(high == low + 1)
	{
		ListNode* resultList = mergeTwoLists(lists.at(low) , lists.at(high) );
		//划分后要返回两个链表归并后的结果，用于继续归并，需要保留所有归并的链表，用于最后删除，似乎在后面会加入该归并链表
		//mergeLists.push_back(resultList);
		return resultList;
	}
	//说明此时存在多个链表等待归并，应该先划分
	else
	{
		int mid = low + (high - low)/2;
		//得到归并后结果，然后执行最后一次归并。 归并过程中返回的大多是新建的一个链表，如果不释放，就会内存泄漏
		ListNode* list1 = merge(lists , low , mid , mergeLists);
		ListNode* list2 = merge(lists , mid + 1 , high , mergeLists);
		mergeLists.push_back(list1);
		mergeLists.push_back(list2);
		ListNode* resultList = mergeTwoLists(list1 , list2);
		mergeLists.push_back(resultList);
		//划分后要返回两个链表归并后的结果，用于继续归并
		return resultList;
	}
}

2 报错:
Runtime Error Message:
Error: attempt to access an element in an empty container.
原因:弹出数组元素没有对数组做判空处理

Runtime Error Message:
double free or corruption (fasttop): 0x0000000001e10e70 ***
似乎是多重释放，注释掉析构函数即可
*/

struct ListNode {
     int val;
     ListNode *next;
     ListNode(int x) : val(x), next(NULL) {}
 };

class Solution {
public:
	//归并排序，这里统一返回新的结果的话，没有问题
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(NULL == l1 && NULL == l2)
		{
			return NULL;
		}
		if(NULL == l1)
		{
			return l2;
		}
		if(NULL == l2)
		{
			return l1;
		}
		ListNode* l3 = NULL;
		ListNode* tail;
		ListNode* l1Copy = l1;
		ListNode* l2Copy = l2;
		//将最终结果插入链表l1中。
		while(l1 && l2)
		{
			if(l1->val < l2->val)
			{
				//如果链表3不空，则直接插入到链表3中
				if(l3)
				{
					ListNode* node = new ListNode(l1->val);
					tail->next = node;
					tail = node;
				}
				//说明链表3的头结点还没有建立
				else
				{
					l3 = new ListNode(l1->val);
					tail = l3;
				}
				l1 = l1->next;
			}
			else
			{
				//如果链表3不空，则直接插入到链表3中
				if(l3)
				{
					ListNode* node = new ListNode(l2->val);
					tail->next = node;
					tail = node;
				}
				//说明链表3的头结点还没有建立
				else
				{
					l3 = new ListNode(l2->val);
					tail = l3;
				}
				l2 = l2->next;
			}
		}
		//判断是否某个链表不为空，则直接连接到结果链表末尾
		if(l1)
		{
			tail->next = l1;
		}
		else if(l2)
		{
			tail->next = l2;
		}
		l1 = l1Copy;//还原结点
		l2 = l2Copy;
		return l3;
    }

	ListNode* merge(vector<ListNode*>& lists , int low , int high ,vector<ListNode*>& mergeLists )
	{
		if(lists.empty() || low > high)
		{
			return NULL;
		}
		int size = lists.size();
		if(low < 0 || high < 0 || low >= size || high >= size)
		{
			return NULL;
		}
		//如果此时恰好只有一个链表，直接返回
		if(low == high)
		{
			return lists.at(low);
		}
		//如果此时有两个链表，就进行两个链表的排序处理
		else if(high == low + 1)
		{
			ListNode* resultList = mergeTwoLists(lists.at(low) , lists.at(high) );
			//划分后要返回两个链表归并后的结果，用于继续归并，需要保留所有归并的链表，用于最后删除，似乎在后面会加入该归并链表
			//mergeLists.push_back(resultList);
			return resultList;
		}
		//说明此时存在多个链表等待归并，应该先划分
		else
		{
			int mid = low + (high - low)/2;
			//得到归并后结果，然后执行最后一次归并。 归并过程中返回的大多是新建的一个链表，如果不释放，就会内存泄漏
			ListNode* list1 = merge(lists , low , mid , mergeLists);
			ListNode* list2 = merge(lists , mid + 1 , high , mergeLists);
			mergeLists.push_back(list1);
			mergeLists.push_back(list2);
			ListNode* resultList = mergeTwoLists(list1 , list2);
			mergeLists.push_back(resultList);
			//划分后要返回两个链表归并后的结果，用于继续归并
			return resultList;
		}
	}

    ListNode* mergeKLists(vector<ListNode*>& lists) {
		if(lists.empty())
		{
			return NULL;
		}
		_lists = lists;
		int size = lists.size();
		int low = 0;
		int high = size - 1;
		vector<ListNode*> mergeLists;
		ListNode* resultList = merge(lists, low , high , mergeLists);
		_mergeLists = mergeLists;
		_resultList = resultList;
		//删除最后的结果。易错，弹出元素必须判空
		if(!mergeLists.empty())
		{
			mergeLists.pop_back();
		}
		//releaseLists(mergeLists);
		return resultList;
    }

	~Solution()
	{
		releaseLists(_lists);
		releaseLists(_mergeLists);
		releaseList(_resultList);
	}

	void releaseLists(vector<ListNode*>& lists)
	{
		if(!lists.empty())
		{
			int size = lists.size();
			for(int i = 0 ; i < size ; i++)
			{
				ListNode* head = lists.at(i);
				releaseList(head);
			}
		}
	}

	void releaseList(ListNode* head)
	{
		while(head)
		{
			ListNode* node = head->next;
			delete head;
			head = node;
		}
	}
public:
	vector<ListNode*> _mergeLists;
	vector<ListNode*> _lists;
	ListNode* _resultList;
};

ListNode* buildList(vector<int>& datas)
{
	if(datas.empty())
	{
		return NULL;
	}
	int size = datas.size();
	ListNode* head = NULL;
	ListNode* tail = NULL;
	for(int i = 0 ; i < size ; i++)
	{
		if(i)
		{
			ListNode* node = new ListNode(datas.at(i));
			tail->next = node;
			tail = node;
		}
		else
		{
			head = new ListNode(datas.at(i));
			tail = head;
		}
	}
	return head;
}

void print(ListNode* head)
{
	if(NULL == head)
	{
		cout << "No result" << endl;
		return;
	}
	ListNode* tempHead = head;
	while(tempHead)
	{
		cout << tempHead->val << " ";
		tempHead = tempHead->next;
	}
	cout << endl;
}

void process()
{
	int listNum;//链表个数，每个链表的元素个数
	vector<int> sizes;
	int size;
	vector<ListNode*> lists;
	int value;
	vector< vector<int> > datas;
	while(cin >> listNum)
	{
		sizes.clear();
		for(int i = 0 ; i < listNum ; i++)
		{
			cin >> size;
			sizes.push_back(size);
		}
		lists.clear();
		//接下来输入每个链表
		for(int i = 0 ; i < listNum ; i++)
		{
			size = sizes.at(i);
			vector<int> listData;
			for(int j = 0 ; j < size ; j++)
			{
				cin >> value;
				listData.push_back(value);
			}
			datas.push_back(listData);
		}
		//构建链表
		for(int i = 0 ; i < listNum ; i++)
		{
			vector<int> listData = datas.at(i);
			ListNode* head = buildList(listData);
			lists.push_back(head);
		}
		Solution solution;
		ListNode* resultList = solution.mergeKLists(lists);
		print(resultList);
		//solution.releaseLists(lists);
		//solution.releaseList(resultList);
	}
}

int main(int argc , char* argv[])
{
	process();
	getchar();
	return 0;
}