[leetcode]Merge k Sorted Lists

此题一开始以为是k*n的复杂度。后来网上搜索了一下，发现有好思路，一是两两归并，这样是logk*n；另外是使用堆，复杂度一样。感觉是归并好写，就采用归并。

1. 归并两路不需要新建节点，其实就是把原有节点的指针交错一下即可；2.二级指针的使用还是不熟练，pplast的名字就是典型应用上一个指针的指针；3.多路归并时想递归来着，但又要新建vector，其实看了一下只需要记录size并不断除以2就行了。

#include <vector>

using namespace std;

class Solution {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
    	int size = lists.size();
		if (size < 1) return 0;
		if (size == 1) return lists[0];
		
		while (size > 1)
		{
			int half = (size  + 1)/ 2;
			for (int i = 0; i + half < size; i++)
			{
				ListNode * first = lists[i];
				ListNode * second = lists[i + half];
				ListNode * result = mergeTwoLists(first, second);
				lists[i] = result;
			}
			size = half;
		}
		return lists[0];
    }

	ListNode * mergeTwoLists(ListNode * l1, ListNode * l2) {
		ListNode * proot = 0;
		ListNode ** pplast = &proot;
		while (l1 && l2)
		{
			ListNode * min = 0;
			if (l1 -> val <= l2->val)
			{
				min = l1;
				l1 = l1->next;
			}
			else
			{
				min = l2;
				l2 = l2->next;
			}
			*pplast = min;
			pplast = &(min->next);
		}

		*pplast = l1 ? l1 : l2;
		return proot;
	}
};

Python2（Python3的priority queue需要覆盖ListNode的__lt__比较方法）

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

from Queue import PriorityQueue

class Solution(object):
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        dummy = point = ListNode(0)
        q = PriorityQueue()
        for lst in lists:
            if lst:
                q.put((lst.val, lst))
        while not q.empty():
            val, node = q.get()
            point.next = ListNode(val)
            point = point.next
            if node.next:
                q.put((node.next.val, node.next))

        return dummy.next