leetcode 上的23题。
//给你一个链表数组,每个链表都已经按升序排列。
//
// 请你将所有链表合并到一个升序链表中,返回合并后的链表。
//
//
//
// 示例 1:
//
// 输入:lists = [[1,4,5],[1,3,4],[2,6]]
//输出:[1,1,2,3,4,4,5,6]
//解释:链表数组如下:
//[
// 1->4->5,
// 1->3->4,
// 2->6
//]
//将它们合并到一个有序链表中得到。
//1->1->2->3->4->4->5->6
//
//
// 示例 2:
//
// 输入:lists = []
//输出:[]
//
//
// 示例 3:
//
// 输入:lists = [[]]
//输出:[]
分析
这个题目,很明显用归并排序能得到最优解。归并排序的核心就是分,合,分是要找到分界点,合是把分界点两边的合并起来。
private ListNode merge(ListNode[] lists, int i, int j) {
// 1. 判定边界值i,j,
// 2. 找到分界点
// 3. 分界点左右分别排序
// 4. 合并排序后的左右两边
}
public ListNode mergeKLists(ListNode[] lists) {
// ListNode ans = null;
// for (ListNode list : lists) {
// ans=mergeTwoList(ans, list);
// }
// return ans;
// 分治算法 类似二分法查找,先分再治===》先分成2部分,再合并 分 (1->n) ===>(1,n/2) (2/n+1,n)
// 治:合并
return merge(lists, 0, lists.length - 1);
}
private ListNode merge(ListNode[] lists, int i, int j) {
if (i > j) {
return null;
}
if (i == j) {
return lists[i];
}
int mid = (j + i) >> 1;
ListNode l1 = merge(lists, i, mid);
ListNode l2 = merge(lists, mid + 1, j);
ListNode listNode = mergeTwoList(l1, l2);
return listNode;
}
private ListNode mergeTwoList(ListNode ans, ListNode list) {
ListNode dummp = new ListNode(0);
ListNode head = dummp;
while (ans != null && list != null) {
if (ans.val < list.val) {
dummp.next = ans;
ans = ans.next;
} else {
dummp.next = list;
list = list.next;
}
dummp = dummp.next;
}
if (ans == null) {
dummp.next = list;
} else {
dummp.next = ans;
}
return head.next;
}
2. 如果是数组呢?同样适合这样的套路。
public static void main(String[] args) {
int[] data = new int[]{5, 3, 6, 2, 1, 9, 4, 8, 7};
print(data);
int[] sort = sort(data, 0, data.length);
System.out.println("排序后的数组:");
print(sort);
// int[] merge = merge(new int[]{3, 5}, new int[]{2, 6});
// System.out.println(merge);
}
public static int[] sort(int[] a, int low, int high) {
int[] temp = Arrays.copyOfRange(a,low,high);
if (temp.length < 2) {
return temp;
}
int mid = (low + high) / 2;
int[] a1 = sort(a, low, mid);
int[] a2 = sort(a, mid , high);
//左右归并
return merge(a1, a2);
}
public static int[] merge(int[] a1, int[] a2) {
int len = a1.length;
int len2 = a2.length;
int i = 0;
int j = 0;
int index = 0;
int[] ans = new int[len + len2];
while (i < len && j < len2) {
if (a1[i] < a2[j]) {
ans[index++] = a1[i++];
} else {
ans[index++] = a2[j++];
}
}
while (i < len) {
ans[index++] = a1[i++];
}
while (j < len2) {
ans[index++] = a2[j++];
}
return ans;
}
public static void print(int[] data) {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + "\t");
}
System.out.println();
}
总结
其实分界点相对好找,一般就是找中点,难的是在排序的时候返回的结果。
针对数组,最终肯定是返回一个元素数组
针对链表,最终返回的是一个指针。