Quick Sort es una complejidad temporal del
o(n^2)algoritmo en el peor de los casos . Aunque la complejidad del tiempo en el peor de los casos es baja, la clasificación rápida suele ser la mejor opción en las aplicaciones de clasificación reales porque su rendimiento promedio es muy bueno: la complejidad de clasificación del tiempo esperado eso(nlgn)
descripción
Al igual que la ordenación por fusión, el algoritmo de ordenación rápida también utiliza la idea de dividir y conquistar. Los siguientes son los tres procesos de división y conquista de ordenación rápida:
-
Descomposición: partición de matriz, aquí tomamos el último elemento como el estándar de partición, y la lógica de la partición se muestra en la siguiente figura:
-
Solución: llame de forma recursiva a la ordenación rápida para ordenar las matrices izquierda y derecha.
-
Fusión: debido a que las submatrices se ordenan in situ, no es necesario fusionarlas.
lograr
Implementación de la partición de matriz: use el último elemento como elemento de muestra para particionar. Divida la matriz en tres grupos: izquierda, centro (área de almacenamiento de elementos de muestra) y derecha. El área izquierda es más pequeña que el medio, el área derecha es más grande que el medio
/**
* 数组分区算法
* 以最后一个元素为样本元素，进行分区
* 将数组划分为左、中（样本元素存放区域）、右三组。左侧区域小于中，右侧区域大于中
*
* @param array 待排序数组
* @param start 数组开始位置
* @param end 数组结束位置
* @return 样本元素位置
*/
private static int partition(int[] array, int start, int end) {
int sample = array[end];
//默认左侧区域为空
int leftEnd = start - 1;
int temp;
for (int j = start; j < end; j++) {
//如果当前位置元素值小于样本值
if (array[j] <= sample) {
//将当前元素移动到左侧区域，即左侧区域空间增加1
leftEnd++;
temp = array[leftEnd];
array[leftEnd] = array[j];
array[j] = temp;
}
}
//将样本元素移动到中间区域，也就是与左侧区域紧挨着
//leftEnd + 1 就是样本元素所在位置
//如此形成左、中、右的区间排布
temp = array[leftEnd + 1];
array[leftEnd + 1] = array[end];
array[end] = temp;
//输出分区后的数组
System.out.println(Arrays.toString(array));
return leftEnd + 1;
}
Implementación de clasificación: no es muy diferente de otras llamadas recursivas, solo tenga en cuenta que los elementos de muestra deben eliminarse cada vez que se ordena la submatriz.
/**
* 快速排序
* @param array 排序数组
* @param start 数组起始位置
* @param end 数组结束位置
*/
private static void quickSort(int[] array, int start, int end) {
if (start < end){
//对数组进行分区，记录分区后的样本元素位置点位置
int mid = partition(array,start,end);
//对样本元素左侧区域进行递归排序
quickSort(array,start,mid-1);
//对样本元素右侧区域进行递归排序
quickSort(array,mid+1,end);
}
}
Este artículo fue cuatro días más tarde de lo esperado, y fue producido con "tiempo libre" de la apretada agenda ¡La calidad es promedio y el precio insistente! Todos, vamos, el próximo artículo "Algoritmo de clasificación de tiempo lineal"