Ordenación rápida
Introducción
Quicksort (Quicksort) es una mejora de la clasificación de burbujas
La idea básica es : divida los datos que se clasificarán en dos partes independientes clasificándolos , y todos los datos de una parte serán más pequeños que todos los datos de la otra parte , y luego clasifique rápidamente las dos partes de los datos de acuerdo con este método . Todo el proceso de clasificación se puede realizar de forma recursiva , de modo que todos los datos se conviertan en una secuencia ordenada
Tome el ejemplo del maestro: -9,78,0,23, -567,70, estos datos se ordenan de pequeños a grandes
Qué significa clasificación rápida, tomamos un valor (que puede ser reemplazado) 0, colocamos el valor menor que 0 a la izquierda y el mayor que 0 a la derecha . Nota: Este lugar es menor que 0, lo que significa que el lado izquierdo no está necesariamente en orden. ¡El lado derecho no está necesariamente en orden! ! !
Entonces este proceso será recursivo, y se realizará la misma operación a la izquierda, y lo mismo se hará a la derecha
Diagrama
Este gráfico dinámico se basa en el primer número, así que tenga cuidado de no cometer un error.
Análisis de pensamiento
Aún así, esta matriz ** - 9,78,0,23, -567,70 **, seguimos el punto de referencia de 0 bits como dijo el profesor
El subíndice de 9 es 0, y el subíndice de 70 es 5, entonces 5/2 = 2 El número con subíndice 2 es 0, tomamos 0 como valor de referencia
También necesitamos dos índices auxiliares (no necesariamente dos). Uno que se usa para recorrer los datos a la izquierda de 0 es encontrar un número mayor que 0
La otra es encontrar a la derecha un número menor que 0. ¿Cuál es el resultado?
La primera vez : el índice de la izquierda encuentra la posición 78 y la posición de la derecha es -567. Luego lo intercambiamos y releemos el proceso hasta que la izquierda sea menor que 0 y la derecha sea mayor que 0. De -9, -567, 0, 23, 78, 70
Luego, vuelva a realizar la misma operación en ambos lados del valor establecido, que es el primer paso de la recursividad. Luego obtendrá el resultado final de clasificación -9, -567, 0, 23, 70, 78
El proceso de derivación
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/30 19:48
* @Description TODO
* @pojectname 快速排序算法
*/
public class QuickSort {
public static void main(String[] args) {
int[] arr = {
-9,78,0,23,-567,70};
quickSort(arr,0,arr.length-1);
System.out.println(Arrays.toString(arr));
}
public static void quickSort(int[] arr,int left,int right){
int l = left;//左下标
int r = right;//右下标
int temp = 0;//临时变量，交换时使用
//pivot 中轴
int pivot = arr[(left+right)/2];
//while循环的目的是让比pivot值小的放到基准值的左边，比他大的放右边
while (l<r){
//在pivot左边一直找，找到大于等于pivot的值才退出
while (arr[l] < pivot){
l+=1;
}
//在pivot右边一直找，找到小于等于pivot的值才退出
while (arr[r] > pivot){
r-=1;
}
//左边已经全部符合都小于基准值了
if (l>=r){
break;
}
//交换
temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
//如果交换后，发现这个arr[l] == pivot 值相等，r--：前移一步
if (arr[l] == pivot){
r-=1;
}
//如果交换后，发现这个arr[r] == pivot 值相等，l++：后移一步
if (arr[r] == pivot){
l+=1;
}
}
}
}
[-9, -567, 0, 23, 78, 70]
Código final
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/30 19:48
* @Description TODO
* @pojectname 快速排序算法
*/
public class QuickSort {
public static void main(String[] args) {
int[] arr = {
-9,78,0,23,-567,70};
quickSort(arr,0,arr.length-1);
System.out.println(Arrays.toString(arr));
}
public static void quickSort(int[] arr,int left,int right){
int l = left;//左下标
int r = right;//右下标
int temp = 0;//临时变量，交换时使用
//pivot 中轴
int pivot = arr[(left+right)/2];
//while循环的目的是让比pivot值小的放到基准值的左边，比他大的放右边
while (l<r){
//在pivot左边一直找，找到大于等于pivot的值才退出
while (arr[l] < pivot){
l+=1;
}
//在pivot右边一直找，找到小于等于pivot的值才退出
while (arr[r] > pivot){
r-=1;
}
//左边已经全部符合都小于基准值了，右边符合大于基准值
if (l>=r){
break;
}
//交换
temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
//如果交换后，发现这个arr[l] == pivot 值相等，r--：前移一步
if (arr[l] == pivot){
r-=1;
}
//如果交换后，发现这个arr[r] == pivot 值相等，l++：后移一步
if (arr[r] == pivot){
l+=1;
}
}
//如果l == r 必须l++,r--，需要错开，不错开的话会栈溢出的
if (l == r){
l += 1;
r -= 1;
}
//向左递归
if (left < r){
quickSort(arr,left,r);
}
if (right>l){
quickSort(arr,l,right);
}
}
}
Es solo que se agrega una operación recursiva al final del proceso de derivación, que es bastante abstracto y hay muchos pasos. Podemos establecer un punto de interrupción al ordenar para comprender