从合并K个排序链表来总结归并的思想

归并的是啥？

简单来说就是把数组中的两个排好序的数组进行合并，然后生成一个排好序的新的数组。
那么怎样把排好序的数组给找出来呢？具体的方法就是，去选更小范围的数组进行两两合并。

归并为什么快？？？

从某种意义上来说，他减少了比较的次数，而减少的比较次数的前提是什么？前提是你的另一半已经做好了准备了，所以归并才有了去减少比较次数的被本钱。
减少了哪些？首先左部分的元素是不用和左部分的元素进行同组比较的。还有就是只要和右部分的一个元素进行比较就行了。

归并排序的步骤

1 找中点：其实就是中点
2 从中拆开：分成前半部分排序和分成后半部分排序
3 合并：把前后两个部分的排序好的数组拼接起来，其实这个步骤是最重要的步骤。

我们可以来看看代码，代码之中有注释，你可以结合注释来理解归并排序：

public void merge_all(int[] arr, int start, int finish) {
    if (start >= finish) {
        return;
    }
    int mid = start + ((finish - start) >> 1);
    merge_all(arr, start, mid);
    merge_all(arr, mid + 1, finish);
    merge_new(arr, start, mid, finish);
}

public void merge_new(int[] arr, int left, int mid, int right) {
	// 初始化一个大小就和区间一样的数组。
    int[] tempArr = new int[right - left + 1];
    int leftIndex = left;
    int rightIndex = mid + 1;
    int index = 0;
    // 先两两比较，先把两个数组中的排好序的数组逐个插入到临时的数组中。
    while (leftIndex <= mid && rightIndex <= right) {
        if (arr[leftIndex] <= arr[rightIndex]) {
            tempArr[index++] = arr[leftIndex ++];
        } else {
            tempArr[index++] = arr[rightIndex++];
        }
    }
   
    // 如果左边的还没插入完全，那么再插入左边的。
    while (leftIndex <= mid) {
        tempArr[index++] = arr[leftIndex++];
    }
   
    // 如果右边的还没插入完全，那么插入右边的。
    while (rightIndex <= right) {
        tempArr[index++] = arr [rightIndex++];
    }
   
    // 最后一步，就是把临时数组的数据复制到原来的数组中。
    for (int i = 0; i <= right - left; ++i) {
        arr[left + i] = tempArr[i];
    }
}

所以最开始两两排序就成了很重要的步骤了。只有其中一个部分的排序完成了，这样才可以保证只要和另一半的首个数字进行比较才行。这样其实减少了很多比较的次数。
那么结合归并的思想，我们来看看下面这道算法题。

23. 合并K个排序链表

https://leetcode-cn.com/problems/merge-k-sorted-lists/

其实对于多数的人来说，能理解算法思想，和能够正确地得到答案是两码事。
这里的主要的思想就是分治的思想，最先能完成的一定是两两合并，然后在不断往上走，然后完成大统一。其实有看归并的代码的朋友是很熟悉这种代码的模式的。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
       if (lists == null || lists.length == 0) {
            return null;
        }
        return mergeSort(lists, 0, lists.length - 1);
    }

    private ListNode mergeSort(ListNode[] lists, int start, int finish) {
        if (start == finish) {
            return lists[start];
        }
        int mid = start + ((finish - start) >> 1);
        ListNode leftNode = mergeSort(lists, start, mid);
        ListNode rightNode = mergeSort(lists, mid + 1, finish);
        return merge(leftNode, rightNode);
    }
    
    public ListNode merge(ListNode head1, ListNode head2) {
        ListNode indexHead1 = head1;
        ListNode indexHead2 = head2;
        ListNode dummyNode = new ListNode(0);
        ListNode tempNode = dummyNode;
        while (indexHead1 != null && indexHead2 != null) {
            if (indexHead1.val <= indexHead2.val) {
                tempNode.next = new ListNode(indexHead1.val);
                indexHead1 = indexHead1.next;
            } else {
                tempNode.next = new ListNode(indexHead2.val);
                indexHead2 = indexHead2.next;
            }
            tempNode = tempNode.next;
        }
        ListNode start = indexHead1;
        if (indexHead2 != null) {
            start = indexHead2;
        }

        while (start  != null) {
            tempNode.next = new ListNode(start.val);
            tempNode = tempNode.next;
            start = start.next;
        }
        return dummyNode.next;
    }
}

我们先来看看这种写法的耗时，基本上可以算是非常好的写法了。时间复杂度直接达到了O(n*k)。

如果这样看不出好处是什么，我们可以先来看看，一般的思想，那就是逐个两两合并，其实这样就不用考虑什么分治思想了，完全就是考虑链表的合并的代码。
我们来看看逐个两两合并的代码。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if (lists == null || lists.length == 0) {
            return null;
        }
        ListNode res = lists[0];
        for (int i = 1, len = lists.length; i < len; ++i) {
            res = merge(res, lists[i]);
        }
        return res;

    }

    public ListNode merge(ListNode head1, ListNode head2) {
        ListNode indexHead1 = head1;
        ListNode indexHead2 = head2;
        ListNode dummyNode = new ListNode(0);
        ListNode tempdummy = dummyNode;
        while (indexHead1 != null && indexHead2 != null) {
             if (indexHead1.val <= indexHead2.val) {
                tempdummy.next = new ListNode(indexHead1.val);
                tempdummy = tempdummy.next;
                indexHead1 = indexHead1.next;
            } else {
                tempdummy.next = new ListNode(indexHead2.val);
                tempdummy = tempdummy.next;
                indexHead2 = indexHead2.next;
            }
        }
        ListNode start = indexHead1;
        if (indexHead2 != null) {
            start = indexHead2;
        }
        
        while (start  != null) {
            tempdummy.next = new ListNode(start.val);
            tempdummy = tempdummy.next;
            start = start.next;
        }
        return dummyNode.next;
    }
}

这样的代码的时间复杂度是多少？应该是O((n*k)^2)，这就是我们现在的目前的时间复杂度。以下就是上面这种代码的所耗费的时间。

因为每个都要进行比较合并，所以耗时太多。因此进行比较之后，每个元素就算不进行比较，也要在合并的时候遍历到。
所以每个元素凭据只走了logN 下。
因为只前的已经比较好了，所以，一般只要比较索引所对应的元素就好。归并的思想，就是利用小范围的排好序的数组进行比较合并，这样就可以减少了比较和便利的次数。