Algoritmo de clasificación común: clasificación rápida

Introduccion

　　La ordenación rápida es en realidad una mejora de la ordenación de burbujas. La matriz que se clasifica se divide en dos partes por una clasificación, y todos los datos en una parte son más pequeños que todos los datos en la otra parte, y luego las dos partes de datos se separan. Para una clasificación rápida, todo el proceso de clasificación es recursivo y, finalmente, se ordena toda la matriz.

Principio

　　El principio del algoritmo de ordenación rápida es seleccionar un elemento como valor de referencia. Generalmente, se selecciona el primer elemento de la matriz, y el elemento más grande que el valor de referencia se coloca en el lado derecho de la matriz, y el elemento más pequeño que el valor de referencia se coloca en el lado izquierdo de la matriz. El proceso específico es el siguiente:

　　Compare de atrás hacia adelante, encuentre elementos más pequeños que el valor de referencia e intercambie el valor de referencia con el elemento actual.

　　Compare de adelante hacia atrás, encuentre el elemento más grande que el valor de referencia e intercambie el valor de referencia con el elemento actual.

　　Repita el proceso anterior hasta que el índice comparado de adelante hacia atrás y el valor del índice comparado de atrás hacia adelante sean iguales.Para el valor de referencia, los datos de la izquierda son menores o iguales que el valor de referencia, y los datos de la derecha son mayores o iguales que el valor de referencia.

　　Ordene rápidamente las matrices en los lados izquierdo y derecho del valor de referencia hasta que se ordene toda la matriz.

Procedimiento

 QuickSort de clase pública {
     ordenación de vacío estático público  ( int [] arr) {
         if (arr == null || arr.length == 0 )
             arroja una nueva IllegalArgumentException ("error" ); 
        quickSort (arr, 0, arr.length-1 ); 
    } public static void quickSort ( int [] arr, int start, int end) {
         int l = start;
        int r = fin;
        clave int =  
      arr [inicio];
        while (l < r) {
             while (l <r && arr [r]> = clave) 
                r - ;
            if (arr [r] <= clave) { 
                swap (arr, l, r); 
            } 
            while (l <r && arr [l] <= clave) 
                l ++ ;
            if (arr [l]> = clave) { 
                swap (arr, l, r); 
            } 
        } 
        if (inicio < l) 
            quickSort (arr, inicio, l -1 );
        si (r < fin)
            quickSort (arr, r +1 , fin); 
    }
     intercambio vacío estático privado  ( int [] arr, int i, int j) {
         int temp = arr [i]; 
        arr [i] = arr [j]; 
        arr [j] = temp; 
    } 
} 

Resumen　

　　La complejidad de tiempo en el peor de los casos de ordenación rápida es O (n ^ 2), el mejor caso es O (nlogn) y la complejidad de tiempo promedio es O (nlogn).

　　Debido a las llamadas recursivas, O (logn) es el mejor caso para la complejidad del espacio de clasificación rápida y O (n) es el peor de los casos. Algunas personas dicen que la complejidad espacial de la ordenación rápida es O (nlogn), tal vez debido a la llamada recursiva O (logn) * tamaño de matriz O (n)?

　　Dado que la ordenación rápida intercambiará dos elementos no adyacentes, la ordenación rápida es inestable.