LeetCode 23_Merge k Sorted Lists

今天再来写一道，时间过得很快，得加快点儿进度了。

这次是leetcode第13题，难度为hard，算是比较难的题了，但我想这个难度和代码量有关系，这个题真正涉及的算法并不是很高深，对归并排序有所了解的人都应该可以想到正确的算法，关键还是对于合并排序的理解吧。

原题如下：

Merge k sorted
linked lists and return it as one sorted list. Analyze and describe its complexity.

没错，题目就这么一句话，就是让你合并n个有序的链表为一个有序链表。

如果你没有接触过两路合并排序，那恐怕这题就真的hard了，所以有时候做题感觉难并不是题目真的很难，正所谓会者不难难者不会，你觉得难是因为你没有学习过这种理论，所以就像个外行人一样，只能来看看热闹。还是那句话，数据结构和算法是程序员必须要掌握的课程，是编程序的理论，而你学的各种语言知识编程的工具，只有工具没有理论，那只能从事一些没有深度的技术工种，当然不是说技术工就没用了，各位可以自己取舍。

下面就开始说编程了，如果你没听过合并排序，还是先去看一下算法书籍较好。

以前接触过的合并排序大多是两路的，也就是给定两个有序数组，然后合并为一个有序数组，用简单的话描述算法就是逐个比较两个数组中的数字，将小的拿到新数组中然后将拿走元素的数字的指针后移，继续比较。

而本次题目给的是k个数组，那我们直接从两路的“推广”过来应该是先比较k个数组的第一个元素，找出最小的拿过来，

然后指针后移再找下一个最小的，直到找完所有元素。我们暂且称这种算法为“推广算法”。

然而要利用两路归并排序的思路去完成对一个无序数组的排序还要有一个不断循环分组的问题，这种分组归并的问题其实就是多路归并问题，根据这种思路，我们可以得到如下算法：先将链表表中的第一和第二个链表合并、第三和第四个链表合并……这样会生成k/2个链表，然后对着k/2个链表继续执行上面的算法，也就是k个变k/2个，再变k/4个，再变k/8个……直到就剩一个链表，我们暂且称这种算法为“分组算法”。

下面我们来分析一下这两种算法的时间复杂度，由于是链表，所以空间复杂度都是O(1)。说实在的，时间复杂度的分析也是一种比较难的知识，要准确推导出表达式还是挺不容易的，我一方面是理论知识不是很强，另一方面时间也比较紧张，所以就不用纯数学的推导了，只做一个定性的分析吧。所以我们假设每个链表的长度相同都为n且k是2的幂，也就是合并完了没有单着的。

先看推广算法，推广算法是要重新连接kn个元素，而找到要连接的元素需要k次比较，所以可以大概知道其时间复杂度为O(kn^2)。

再来看分组算法，第一次分组的时间复杂度为k/2*2n，第二次为k/4*4n(注意链表边长了，所以为4n)……这样一共需要经历log2k次分组归并，所以其时间复杂度大概为O(knlog2k)。

显然，（我其实很讨厌这就话，其实是因为一般情况下O(n)>O(log2k)）分组算法的是时间复杂度小于推广算法，所以分组算法是比较好的，当然应该采用它了。

具体实现中还有两个选择，一是采用循序方法分组，二是采用子函数方法分组，子函数看起来更清晰一点，但我用的还是直接循环，对应的子函数方法大家可以自己试一下。

//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) {
//获取链表的个数
vector<ListNode*>::size_type nListNumber = lists.size();
//如果链表个数为0或者1则不用执行算法
if(nListNumber==0) return NULL;
if(nListNumber==1) return lists[0];//能否和下面合并？

vector<ListNode*> tempListsMergeBefore = lists;//用于存储中间结果
vector<ListNode*> tempListsMergeAfter;//用于存储中间结果

while(nListNumber > 1)
{
vector<ListNode*>::size_type index = 0;
for(;
index+1<nListNumber; index+=2)
{
//本次合并结果头指针
ListNode* pListNodeResultHead;
ListNode* pListNodeResultIndex;//本次合并结果索引指针
ListNode* pListNodeIndex1 = tempListsMergeBefore[index];//第一个链表的索引指针
ListNode* pListNodeIndex2 = tempListsMergeBefore[index+1];//第二个链表的索引指针
//判断是否有空指针
if(pListNodeIndex1 == NULL) pListNodeResultHead = pListNodeIndex2;
else if(pListNodeIndex2 == NULL) pListNodeResultHead = pListNodeIndex1;
else{
//因为没有头结点，所有要特殊处理结果头指针
if(pListNodeIndex1->val < pListNodeIndex2->val)
{
pListNodeResultHead = pListNodeIndex1;
pListNodeResultIndex = pListNodeIndex1;
pListNodeIndex1 = pListNodeIndex1->next;
}
else
{
pListNodeResultHead = pListNodeIndex2;
pListNodeResultIndex = pListNodeIndex2;
pListNodeIndex2 = pListNodeIndex2->next;
}
//开始合并
while(pListNodeIndex1!=NULL && pListNodeIndex2!=NULL)
{
if(pListNodeIndex1->val < pListNodeIndex2->val)
{
pListNodeResultIndex->next = pListNodeIndex1;
pListNodeResultIndex = pListNodeResultIndex->next;
pListNodeIndex1 = pListNodeIndex1->next;
}
else
{
pListNodeResultIndex->next = pListNodeIndex2;
pListNodeResultIndex = pListNodeResultIndex->next;
pListNodeIndex2 = pListNodeIndex2->next;
}

}
if(pListNodeIndex1!=NULL)
pListNodeResultIndex->next=pListNodeIndex1;
else
pListNodeResultIndex->next=pListNodeIndex2;

}
if(pListNodeResultHead!=NULL)
tempListsMergeAfter.push_back(pListNodeResultHead);

}
if(index+1==nListNumber)
tempListsMergeAfter.push_back(tempListsMergeBefore[index]);
//更新参数
nListNumber = tempListsMergeAfter.size();
tempListsMergeBefore = tempListsMergeAfter;
tempListsMergeAfter.clear();
}
return tempListsMergeBefore[0];
}
};

算法比较长，一方面我起的变量名都比较长，二是这个问题代码量确实有点儿大。大家可以在不影响可读性的基础上改进一下，但算法就是这么个情况了。

实际编码过程中还是有几点要注意：

（1）指针判空。这个问题的必要性就不多说了，我只想说，指针不判空者杀无赦！

（2）无头结点的链表。一般链表为了便于对统一操作，都会在链表前加一个没有实际含义的头结点。如果没有这个头结点，那很多链表操作都要对空链表和头指针做特殊处理，这是要注意的一个细节。

（3）链表的索引指针移动。这是一个链表的基本操作的注意点，要想在一个链表中作插入操作，那必须有一个指针是跟随其不断后移的，体现在程序中就是有pNode=pNode->next;这么一句，否则链表是不能连在一起的。

最后，祝每个坚持的人早日实现自己的梦想！