Dirección del evento: Desafío de aprendizaje de 21 días de CSDN
Tabla de contenido
ordenación rápida
Divida los elementos a clasificar en dos partes independientes mediante la clasificación de un solo paso, una de las cuales es el elemento más pequeño que el número de referencia y la otra parte es el elemento más grande que el número de referencia. Luego se ordenan las dos partes de elementos según el algoritmo anterior, hasta que solo quede un elemento en cada parte.
En esencia, la ordenación rápida debe considerarse como un método recursivo de divide y vencerás basado en la ordenación de burbujas.
Principio del algoritmo
-
Elija un elemento de la secuencia como punto de referencia
-
Reordene la secuencia, todos los elementos más pequeños que el valor de referencia se colocan delante de la referencia y todos los elementos más grandes que el valor de referencia se colocan detrás de la referencia
-
Luego, los lados izquierdo y derecho del valor de referencia, repita los pasos anteriores
-
Ordene las matrices en los lados izquierdo y derecho del elemento de valor de referencia por recursión. Después de ordenar, se ordena toda la matriz.
diagrama
Descripción del problema:
Dada una matriz de números desordenados, se puede generar en orden
Ejemplo:
输入: nums = [4，3，1，2，9，6],
输出: nums = [1，2，3，4，6，9]
El diagrama es el siguiente:
Implementación de código Java
código central
public class QuickSort {
//比较 v 是否小于 w
public static boolean less(Comparable v,Comparable w){
return v.compareTo(w) < 0;
}
//数组元素交换位置
private static void swap(Comparable[] a,int i,int j){
Comparable temp;
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
//排序
public static void sort(Comparable[] a){
int l = 0;
int h = a.length - 1;
sort(a,l,h);
}
private static void sort(Comparable[] a,int l,int h){
if (h <= l) return;
//对数组进行分组(左右两个数组)
// i 表示分组之后基准值的索引
int i = partition(a, l, h);
//让左边的数组有序
sort(a,l,i - 1);
//让有边的数组有序
sort(a,i + 1,h);
}
public static int partition(Comparable[] a,int l,int h){
//确定基准值
Comparable key = a[l];
//定义两个指针
int left = l;
int right = h + 1;
//切分
while (true){
//从右向左扫描，移动right指针找一个比基准值小的元素，找到就停止
while (less(key,a[--right])){
if (right == l)
break;
}
//从左向右扫描，移动left指针找一个比基准值大的元素，找到就停止
while (less(a[++left],key)){
if (left == h)
break;
}
if (left>=right){
break;
}else {
swap(a,left,right);
}
}
//交换基准值
swap(a,l,right);
return right;
}
}
public class QuickSortTest {
public static void main(String[] args) {
Integer[] arr = {
3,1,2,4,9,6};
QuickSort.sort(arr);
System.out.println(Arrays.toString(arr));
}
}
//排序前：{3,1,2,4,9,6}
//排序后：{1,2,3,4,6,9}
resultado de la operación:
Análisis de Algoritmos
- complejidad del tiempo
El mejor caso de ordenación rápida es que cada elemento extraído simplemente biseca la matriz completa.Dado que la ordenación rápida usa llamadas recursivas, la complejidad de tiempo de la ordenación rápida también debe calcularse usando algoritmos recursivos. T[n] = 2T[n/2] + f(n), la complejidad temporal es O(nlogn). En el peor de los casos, como la ordenación de burbujas, cada comparación necesita intercambiar elementos y la complejidad del tiempo es O(n^2).
Por lo tanto, la complejidad temporal de ordenación rápida es: O(nlogn).
- complejidad del espacio
La complejidad del espacio es principalmente el uso del espacio de pila causado por la recursividad. En el mejor de los casos, la profundidad del árbol recursivo es log2n, y la complejidad del espacio es O(logn). En el peor de los casos, se requieren n-1 llamadas recursivas. Esta La complejidad espacio-temporal es O(n).
Por lo tanto, la complejidad espacial de ordenación rápida es: O(logn).