[leetcode] Merge k Sorted Lists

原文链接：http://blog.csdn.net/a83610312/article/details/8554241

题目描述：

        有一系列已排好序的链表，将其合并成有序的一张链表；

 

第一反应是运用胜者树或败者树可以很方便的求解；

因为STL提供了堆操作的函数，所以这里借助堆来求解；

 

思路是：首先将k个链表的第一个节点集合，建堆，然后取出堆顶的节点，链接到结果链表上，然后将该节点的下一个节点入堆，直到所有链表都已经完成；

下面的Node结构体好像根本无必要，刚开始没注意是链表（而链表可以很方便的获取下一个节点，如果是数组的话还得记录它来自哪个数组）；

有亮点需要注意：

1.当一条链表结束的时候，添加值为INF的新Node加入堆，可以方便地避免NULL的判断；

2.make_heap()默认是大顶堆，所以要显示指定使用greater<node>()，来获取小顶堆；

 

[cpp]  view plain copy

1. /** 
2.  * Definition for singly-linked list. 
3.  * struct ListNode { 
4.  *     int val; 
5.  *     ListNode *next; 
6.  *     ListNode(int x) : val(x), next(NULL) {} 
7.  * }; 
8.  */  
9.    
10. #define LN ListNode*  
11. #define HEAP heap.begin(),heap.end()  
12. #define PB push_back  
13. #define INF 1000000  
14.   
15. struct node  
16. {  
17.     int val;  
18.     LN from;  
19.       
20.     node(ListNode* n)  
21.     {  
22.         if ( n==NULL )  
23.         {  
24.             val=INF;  
25.         }  
26.         else  
27.         {  
28.             val=n->val;  
29.         }             
30.         from=n;  
31.     }  
32.     bool operator<(const node& other)const  
33.     {  
34.         return val<other.val;  
35.     }  
36.     bool operator>(const node& other)const  
37.     {  
38.         return val>other.val;  
39.     }  
40. };  
41.       
42. class Solution {  
43. public:  
44.     ListNode *mergeKLists(vector<ListNode *> &lists) {  
45.         // Start typing your C/C++ solution below  
46.         // DO NOT write int main() function  
47.           
48.         if (lists.empty()) return NULL;  
49.     int n= lists.size();  
50.     vector<node> heap;  
51.     heap.reserve(n);  
52.     for( int i=0;i<n;i++)  
53.         heap.PB(node(lists[i]));  
54.     make_heap(HEAP,greater<node>());  
55.     LN head= new ListNode(0);  
56.     LN pL = head;  
57.     pop_heap(HEAP,greater<node>());  
58.     node small=heap.back();  
59.     heap.pop_back();  
60.     while(small.val!=INF)  
61.     {  
62.         LN next=small.from->next;  
63.         pL->next=small.from;  
64.         small.from->next=NULL;  
65.         pL=pL->next;  
66.   
67.         heap.PB(node(next));  
68.         push_heap(HEAP,greater<node>());  
69.         pop_heap(HEAP,greater<node>());  
70.         small=heap.back();  
71.         heap.pop_back();  
72.     }  
73.   
74.     LN ret=head->next;  
75.     delete head;  
76.     return ret;    }  
77. };