Le tri par fusion et son analyse de la complexité temporelle

Le tri par fusion et son analyse de la complexité temporelle

Qu'est-ce que le tri par fusion ?

Le tri par fusion incarne l'idée de diviser pour mieux régner, diviser le tableau d'origine, trier chaque partie séparément, puis les fusionner une par une, et enfin obtenir le résultat souhaité.

1. Diviser le tableau

• trier le tableau

• Comment trier (du plus petit au plus grand)

partie de code

/**
 * @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];
        }
    }
}

Analyse de complexité temporelle

Nous avons constaté que dans les fonctions récursives, les sous-récursions ont la même chance. Ainsi, l'expression principale peut être utilisée.

Voir l'article pour l'expression maître : https://blog.csdn.net/abaidaye/article/details/126603143

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

Parce que dans la fonction de fusion, quoi qu'il arrive, les deux pointeurs s'additionnent pour traverser n nombres donc d=O(n).

Par conséquent, la formule principale pour cette question est : T(n) = 2 * T(n/2) + O(n).

A ce moment $lo{g}_b^{}$== d, donc la complexité temporelle est O(n $lo{g}_2^{}$)