LeetCode-23 合并k个排序链表

合并k个排序链表

使用暴力求解

使用分治法，递归

/**
 * 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) {
		//和并多个有序链表
		//使用的是跟二分法差不多的方法，降低了时间复杂度
		int size_L = lists.size();
		if (size_L == 0)
			return NULL;
		if (size_L == 1)
			return lists[0];
		if (size_L == 2)
			return merge2Lists(lists[0], lists[1]);
		int mid = size_L / 2;
		vector<ListNode*> lists1;
		vector<ListNode*> lists2;
		for (int i = 0; i<size_L; ++i)
		{
			if (i<mid)
				lists1.push_back(lists[i]);
			else
				lists2.push_back(lists[i]);
		}
		//分成两个链表头节点的集合，递归两个子集合，两个子集合合并完得到这个集合的排好序的链表头结点
        ListNode* ph1 = mergeKLists(lists1);
		ListNode* ph2 = mergeKLists(lists2);
		ListNode* result = merge2Lists(ph1, ph2);
		return result;
	}
	//和并两个链表
	ListNode* merge2Lists(ListNode* h1, ListNode* h2)
	{
		ListNode new_head(0);
		ListNode* new_phead = &new_head;
		ListNode* result = &new_head;
		//ListNode* new_head = NULL;
		while (h1&&h2)
		{
			if (h1->val<h2->val)
			{
				new_phead->next = h1;
				h1 = h1->next;				
			}
			else
			{
				new_phead->next = h2;
				h2 = h2->next;				
			}
            new_phead = new_phead->next;
		}
		if (h1)
		{
			new_phead->next = h1;
		}
		else
		{
			new_phead->next = h2;
		}
		return result->next;
	}
};