算法笔记--排序算法-分治法-归并排序

归并排序

时间复杂度

每一层的和都是 cn，共有 lgn+1 层，因此总的执行时间是 cnlgn + cn，相比 nlgn 来说，cn 项可以忽略，因此 T(n) 的上界是 Θ(nlgn)。

注：

设有 n 个叶子结点，满二叉树的层数为 k，有 2^k-1=n，即 k-1=log₂n，所以 k=lgn +1。就是说共有 lgn + 1 层

设每个叶子结点的执行时间是 c，则每一层的执行时间是 cn。

所以总执行时间是 cn ( lgn + 1 ) = cnlgn + cn。

Java代码

public class MergeSort {
    
    public void sort(int a[], int s, int e) {
        if (s < e && s >= 0 && e < a.length) {
            int i = (s + e) / 2;
            sort(a, s, i); //左半边数组递归
            sort(a, i + 1, e); //右半边数组递归
            compareSort(a, s, e); //具体的计算方法
        }
    }

    private void compareSort(int[] a, int s, int e) {
        if (s >= 0 && e < a.length && e > s) {
            int m = (s + e) / 2 + 1;  //中间位置
            int start = s;
            int mid = m;            
            int[] temp = new int[e - s + 1];
            int index = 0;
            
            //将数组劈成两半，以两边数组的左边第一个索引指向的数字开始互相比较，较小数的存入temp数组，索引+1
            while (start < m && mid <= e) {
                if (a[start] <= a[mid]) {
                    temp[index] = a[start];
                    start++;
                } else {
                    temp[index] = a[mid];
                    mid++;
                }
                index++;
            }
            
            //把没比较完的数按顺序写到temp数组中
            if (index < temp.length) {
                if (start < m)
                    for (int i = start; i < m; i++) {
                        temp[index++] = a[i];
                    }
                else if (mid <= e)
                    for (int i = mid; i <= e; i++) {
                        temp[index++] = a[i];
                    }
            }
            for (int i = 0; i <= index; i++) {
                if (s + i <= e) {
                    a[s + i] = temp[i];
                }
            }
        }
    }
}