Merge sort y su análisis de complejidad temporal

Merge sort y su análisis de complejidad temporal

¿Qué es la ordenación por fusión?

La clasificación por combinación encarna la idea de dividir y vencer, dividir la matriz original, ordenar cada parte por separado y luego fusionarlas una por una y finalmente lograr el resultado que queremos.

1. Dividir la matriz

• ordenar la matriz

• Cómo ordenar (de pequeño a grande)

parte del código

/**
 * @author `dongxu.kwb`
 * @date `2022/8/30`
 */
public class MergeSort {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    79,3213,3,5,45,65};
        mergeSort(arr);
        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.println(arr[i]);
        }
    }
    public static void mergeSort(int[] arr) {
    
    

        //判断下数组是否为空，或者是一个数

        if (arr == null || arr.length < 2) {
    
    
            return;
        }

        //给整个数组分割并且排序

        process(arr, 0, arr.length - 1);
    }

    /**
     * 主要负责递归
     * @param arr
     * @param left
     * @param right
     */

    public static void process(int[] arr, int left, int right) {
    
    

        //递归结束条件

        if (left == right) {
    
    
            return;
        }

        //找中点

        int mid = left + ((right - left) >> 1);

        //左右拆分并且排序

        process(arr, left, mid);
        process(arr, mid + 1, right);

        //排序

        merge(arr, left, mid, right);
    }

    /**
     * 主要负责排序
     * @param arr
     * @param left
     * @param mid
     * @param right
     */

    public static void merge(int[] arr, int left, int mid, int right) {
    
    
        int[] help = new int[right - left + 1];
        int i = 0;
        int p1 = left; //左指针
        int p2 = mid + 1; //右指针

        //如果左右指针都没超出边界

        while (p1 <= mid && p2 <= right) {
    
    
            help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
        }

        //左指针超出边界

        while (p1 <= mid) {
    
    
            help[i++] = arr[p1++];
        }

        //右指针超出边界

        while (p2 <= right){
    
    
            help[i++] = arr[p2++];
        }

        //将排好序的部分同步到arr原数组中

        for (int i1 = 0; i1 < help.length; i1++) {
    
    
            arr[left + i1] = help[i1];
        }
    }
}

Análisis de la complejidad del tiempo

Encontramos que en las funciones recursivas, las subrecursiones tienen la misma posibilidad. Entonces se puede usar la expresión maestra.

Consulte el artículo para la expresión maestra: https://blog.csdn.net/abaidaye/article/details/126603143

        process(arr, left, mid);
        process(arr, mid + 1, right);

Porque en la función de combinación, pase lo que pase, los dos punteros se suman para recorrer n números, por lo que d=O(n).

Por lo tanto, la fórmula maestra para esta pregunta es: T(n) = 2 * T(n/2) + O(n).

En este momento $registro\_{\_}_b^{}$== d, entonces la complejidad del tiempo es O(n $registro\_{\_}_2^{}$)