归并排序-链表与数组

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();
    }

总结

其实分界点相对好找，一般就是找中点，难的是在排序的时候返回的结果。
针对数组，最终肯定是返回一个元素数组
针对链表，最终返回的是一个指针。