Análisis del algoritmo de clasificación por fusión

Análisis del algoritmo de clasificación por fusión

1. Pensamiento algorítmico

Usando la idea de divide y vencerás, la matriz original se divide en dos partes cada vez, luego se ordenan las submatrices y, finalmente, las matrices ordenadas se fusionan para formar una nueva secuencia ordenada.

1.1 Proceso de ejecución

2. Pasos de implementación

2.1 método mergeSort()

public static void mergeSort(int[]arr){
    
    
        if (arr == null || arr.length < 2){
    
    
            return;
        }
        mergeSort(arr,0,arr.length-1);
    }

2.2 Dividir en varios subarreglos

 public static void mergeSort(int[] arr, int l, int r) {
    
    
		//如果l和r相等，说明中间只有一个数，数组已经排好序了。
		if (l == r) {
    
    
			return;
		}
		int mid = l + ((r - l) >> 1);//求中点
		//l到mid之间变为有序的
		mergeSort(arr, l, mid);
		//mid+1到r之间变成有序的
		mergeSort(arr, mid + 1, r);
		
		merge(arr, l, mid, r);
	}

2.3 Fusionar subarreglos

public static void merge(int[] arr ,int l ,int m ,int r){
    
    
        //辅助数组长度的大小
		int[] help = new int[r - l + 1];
		int i = 0;//辅助数组指针
		int p1 = l;//左边数组指针
		int p2 = m + 1;//右边数组指针
		while (p1 <= m && p2 <= r) {
    
    
			help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
		}
//		有一边结束了就输入另一边
		while (p1 <= m) {
    
    
			help[i++] = arr[p1++];
		}
		while (p2 <= r) {
    
    
			help[i++] = arr[p2++];
		}
		for (i = 0; i < help.length; i++) {
    
    
			arr[l + i] = help[i];
		}
	}

3. Análisis de la complejidad del tiempo.

Utilice la fórmula de Master para analizar la complejidad temporal del comportamiento recursivo

La fórmula de comparación es: T(N) = 2 T(N/2) + O(N); *

Entonces la complejidad del tiempo es O (N * log N);