Combinar ordenación
principio
La idea central de Merge Sort (Merge Sort) es que si queremos ordenar una matriz, primero dividimos la matriz en dos partes desde el medio, y luego clasificamos las dos partes por separado, y luego fusionamos las dos partes ordenadas. , de modo que todos los arrays estén ordenados. El tipo de combinación utiliza la idea de dividir y conquistar.
Divide y conquistaras
Dividir y conquistar, como su nombre lo indica, es dividir y conquistar, resolver un gran problema en subproblemas más pequeños. Cuando se resuelven los pequeños subproblemas, se resuelven los grandes problemas. Las ideas de dividir y conquistar generalmente se implementan por recursividad. Dividir y conquistar es una idea de procesamiento para resolver problemas, y la recursividad es una técnica de programación, las dos no entran en conflicto. Para la recursividad, es necesario encontrar la fórmula de recursión y las condiciones de terminación, así que escriba la fórmula recursiva mergeSort (m-> n) = merge (mergeSort (m-> k), mergeSort (k + 1-> n)); Terminate cuando m = n. Es decir, cuando queremos ordenar la secuencia entre m-> n, podemos dividirla en ordenar la secuencia entre m-> k, y ordenar la secuencia entre k + 1-> n, y luego conectar la fusión de la la serie ordenada se denomina serie final De la misma manera, la clasificación de cada serie puede continuar dividiéndose para formar una recursividad.
El proceso del algoritmo es el siguiente
Descripción del algoritmo:
- Divida la secuencia de entrada de longitud n en dos subsecuencias de longitud n / 2;
- Utilice el ordenamiento combinado para estas dos subsecuencias respectivamente;
- Finalmente, las dos subsecuencias ordenadas se fusionan en una secuencia ordenada final.
Código
public class MergeSort {
//1.如果要排序一个数组，我们先把数组从中间分成前后两部分，然后对前后两部分分别排序
//2.再将排好序的两部分合并在一起，这样整个数组就都有序了
public static void main(String[] args) {
int[] array = {
5, 2, 6, 9, 0, 3, 11, 7};
MergeSort sort = new MergeSort();
int[] ints = sort.mergeSort(array);
System.out.println(Arrays.toString(ints));
}
public int[] mergeSort(int[] arr) {
if (arr.length < 2) {
return arr;
}
//将数组从中间拆分成左右两部分
int mid = arr.length / 2;
int[] left = Arrays.copyOfRange(arr, 0, mid);
int[] right = Arrays.copyOfRange(arr, mid, arr.length);
return merge(mergeSort(left), mergeSort(right));
}
//合并两个有序数组并返回新的数组
public int[] merge(int[] left, int[] right) {
//创建一个新的数组，等于left+right之和
int[] newArray = new int[left.length + right.length];
//定义两个指针,分别代表两个数组的下标
int lindex = 0;
int rindex = 0;
for (int i = 0; i < newArray.length; i++) {
if(lindex >= left.length){
newArray[i] = right[rindex++];
}else if(rindex >= right.length){
newArray[i] = left[lindex++];
}else if(left[lindex] < right[rindex] ){
newArray[i] = left[lindex++];
}else{
newArray[i] = right[rindex++];
}
}
return newArray;
}
}
1: ¿Cuál es la complejidad temporal de la ordenación por fusión?
La eficiencia de ejecución de la ordenación por fusión no tiene nada que ver con el orden de la matriz original que se va a ordenar, por lo que su complejidad de tiempo es muy estable, independientemente del mejor caso, el peor de los casos o el caso promedio, la complejidad de tiempo es O (nlogn) .
2: ¿Cuál es la complejidad espacial del tipo de combinación ?
La complejidad espacial de la ordenación por fusión es O (n).
3: ¿Es la ordenación por fusión un algoritmo de ordenación estable?
La estabilidad del algoritmo de clasificación de combinación no depende de la función de combinación merge (). Es decir, la parte del código donde dos submatrices ordenadas se fusionan en una matriz ordenada Al analizar la función de fusión, encontramos que la ordenación por fusión también es un algoritmo de clasificación estable .