我的LeetCode：https://leetcode-cn.com/u/ituring/

我的LeetCode刷题源码[GitHub]：https://github.com/izhoujie/Algorithmcii

LeetCode 23. 合并K个排序链表

题目

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

示例:

输入:
[
  1->4->5,
  1->3->4,
  2->6
]
输出: 1->1->2->3->4->4->5->6

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-k-sorted-lists
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

很明显的topK问题；

• 使用最小堆或者优先队列；
• 分治，折半合并排序；

思路1-使用优先队列/最小堆

步骤：

1. 使用PriorityQueue优先队列，需要实现Comparator接口的compare方法；
2. 不断取出头部节点对象拼接新链表；

算法复杂度: n为节点总数

• 时间复杂度： $ {\color{Magenta}{\Omicron\left(nlogk\right)}} $
• 空间复杂度： $ {\color{Magenta}{\Omicron\left(k\right)}} $

思路2-分治折半合并排序

步骤：

1. 每次折半首位对应的链表合并排序，结果给到靠首部的位置；
2. 每次折半排序后的长度重置为（n+1）/2，解决长度为奇偶的问题；

算法复杂度: n为节点总数

• 时间复杂度： $ {\color{Magenta}{\Omicron\left(nlogk\right)}} $
• 空间复杂度： $ {\color{Magenta}{\Omicron\left(logk\right)}} $ 递归时栈的深度

算法源码示例

package leetcode;

import java.util.Comparator;
import java.util.PriorityQueue;

/**
 * @author ZhouJie
 * @date 2020年1月10日 下午8:26:09 
 * @Description: 23. 合并K个排序链表
 *
 */
public class LeetCode_0023 {

}

// Definition for singly-linked list.
class ListNode_0023 {
	int val;
	ListNode_0023 next;

	ListNode_0023(int x) {
		val = x;
	}
}

class Solution_0023 {
	/**
	 * @author ZhouJie
	 * @date 2020年1月10日 下午8:48:38 
	 * @Description: TODO(方法简述) 
	 * @return ListNode_0023 
	 * @UpdateUser-UpdateDate:[ZhouJie]-[2020年1月10日 下午8:48:38]  
	 * @UpdateRemark:1-使用优先队列
	 *
	 */
	public ListNode_0023 mergeKLists_1(ListNode_0023[] lists) {
		if (lists == null) {
			return null;
		}
		// 优先队列，非基础类型需要重写比较器
		PriorityQueue<ListNode_0023> queue = new PriorityQueue<ListNode_0023>(new Comparator<ListNode_0023>() {
			public int compare(ListNode_0023 o1, ListNode_0023 o2) {
				return o1.val - o2.val;
			}
		});
		for (ListNode_0023 node : lists) {
			if (node != null) {
				queue.add(node);
			}
		}
		ListNode_0023 head, now;
		head = now = null;
		while (!queue.isEmpty()) {
			ListNode_0023 node = queue.poll();
			if (head == null) {
				head = now = node;
			} else {
				now.next = node;
				now = node;
			}
			if (node.next != null) {
				queue.add(node.next);
			}
		}
		return head;
	}

	/**
	 * @author ZhouJie
	 * @date 2020年1月10日 下午9:03:07 
	 * @Description: TODO(方法简述) 
	 * @return ListNode_0023 
	 * @UpdateUser-UpdateDate:[ZhouJie]-[2020年1月10日 下午9:03:07]  
	 * @UpdateRemark:2-分治思想，不断折半合并，直至为一个；
	 *
	 */
	public ListNode_0023 mergeKLists_2(ListNode_0023[] lists) {
		int len;
		if (lists == null || (len = lists.length) == 0) {
			return null;
		}
		while (len > 1) {
			for (int i = 0; i < len / 2; i++) {
				// 对半合并，后一半合并到前一半
				lists[i] = mergeHelper(lists[i], lists[len - 1 - i]);
			}
			len = (len + 1) / 2;
		}
		return lists[0];
	}

	/**
	 * @author: ZhouJie
	 * @date: 2020年2月4日 下午2:45:50 
	 * @param: @param l1
	 * @param: @param l2
	 * @param: @return
	 * @return: ListNode_0023
	 * @Description: 合并两个有序链表辅助方法
	 *
	 */
	private ListNode_0023 mergeHelper(ListNode_0023 l1, ListNode_0023 l2) {
		if (l1 == null) {
			return l2;
		} else if (l2 == null) {
			return l1;
		} else if (l1.val < l2.val) {
			l1.next = mergeHelper(l1.next, l2);
			return l1;
		} else {
			l2.next = mergeHelper(l1, l2.next);
			return l2;
		}
	}
}