Clasificación rápida en c

"Quicksort o Story Sorts es un algoritmo de clasificación. Quick Sort es un algoritmo de división y conquista. Deje que la lista de personajes se ordene por:

P W E R T Y U I O P

La lista ordenada es:

E i o p q r t u w y

Esto es algo ascendente. En este artículo, la explicación de QuickSort, clasifica ascendiendo, usando la lista: "Q", "W", "E", "R", "T", "Y", "U", "I", "," O "," P ", y el lenguaje C."

Clasificación rápida en teoría

De la lista, "Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P", se verá rápido para un valor central, llamado pivote. En la lista ordenada,

"E", "I", "O", "P", "Q", "R", "T", "U", "W", "Y"

El pivote es "Q" o "R" ya que la lista es incluso en número. Si la lista fuera impar en número, el pivote claramente habría sido el valor medio. "Q" en el índice 4 se elige como el pivote. Recuerda que la lista a ordenar es,

P W E R T Y U I O P

Y no la lista ordenada. Hay 10 elementos en esta lista sin clasificar.

La primera etapa es buscar el pivote (valor central) en la lista sin clasificar. La segunda etapa es colocar el pivote en su posición legítima en la lista no organizada (en este caso, índice 4); y coloque todos los elementos que son menos que el pivote a la izquierda y todos los elementos que son mayores que el pivote a la derecha. Los elementos a la izquierda del pivote no deben clasificarse necesariamente, y los elementos a la derecha del pivote no deben clasificarse necesariamente. Esta fase es la fase de división o partición en el algoritmo de división y conquista. Hay tres partes para esta etapa: la subproducción izquierda, la subproducción derecha y la subsistencia media. La subproducción media consta de un solo elemento, que es el pivote. Para la lista anterior, el resultado sería:

E i o p q w r t y u

Dado que el pivote ya está en su posición final, la última etapa, en teoría, es ordenar la subsist de la izquierda y ordenar la subsistencia derecha. Esto esta conquistando. Es una coincidencia que la subplaza izquierda, en este caso, ya esté ordenada. La subplaza correcta, en este caso, aún no se puede ordenar. Clasificación de la subsistencia izquierda y derecha por separado, el resultado es:

E i o p q r t u w y

según sea necesario.

Clasificación rápida en la práctica

En la práctica, la partición con alguna clasificación (intercambio) se realiza repetidamente de manera recursiva. Es decir, se desarrollan nuevas sub-listas más pequeñas y más pequeñas con sus propios pivotes. En otras palabras, se están desarrollando sub-listas de tres partes más pequeñas y más pequeñas hasta que se ordene toda la lista.

Hay un problema cuando se trata de elegir el pivote. Toda la lista no organizada no se puede escanear elemento por elemento para obtener el pivote correcto. Que llevará mucho tiempo. Entonces se debe hacer una suposición inteligente.

Recuerde que la lista a ordenar es:

P W E R T Y U I O P

Deje que la suposición inteligente sea P, el elemento más correcto. A continuación, deje que todos los elementos menos que P, leyendo desde la izquierda, vayan a la izquierda de P y deje que todos los elementos mayores que P, aún lean desde la izquierda, vayan a la derecha de P sin clasificar consciente. Esto da:

E i o p q w r t y u

Las primeras tres sub-listas son:

"E", "I", "O", "P", "Q", "W", "R", "T", "Y", "U"

P está en su posición legítima (en la práctica, puede no ser necesariamente índice 4; aquí, es el índice 3 en esta etapa). El siguiente paso es una llamada recursiva para dividir la subconjunta izquierda en tres subsists; y la subsists correcta en tres subsists, cada una con su propio género, de una suposición inteligente.

Dividiendo "e", "i", "o"
Deje que su pivote inteligente sea, o, el elemento más correcto. Todos los elementos que son menos que O tienen que ir a la izquierda, y todos los elementos que son mayores que O tienen que ir a la derecha, leyendo para ambos casos desde la izquierda. Esto da:

"E", "i", "o",

sin elemento a la derecha. Si "e", "i" también se divide recursivamente, entonces ["e", "i", ] dará como resultado. Y así, la primera subsist de la izquierda ordenada, es:

"E", "I", "O"

Dividiendo "Q", "W", "R", "T", "Y", "U"
"Q", "W", "R", "T", "Y", "U" es la primera subsistencia derecha. Deje que su pivote inteligente suponga que es u, el elemento más correcto. Todos los elementos que son menos que usted tiene que ir a la izquierda, y todos los elementos que son mayores que usted tiene que ir a la derecha; lectura para ambos casos, desde la izquierda. Esto da:

"Q", "R", "T", "U", "W", "T"

Partitando recursivamente "Q", "R", "T" y "W", "T" de la misma manera, la primera subproducción derecha sería:

"Q", "R", "T", "U", "W", "Y"

Y la lista completa de ordenada sería:

E i o p q r t u w y

Tenga en cuenta que cada partición se clasifica en un sentido amplio al colocar valores más bajos no armados en la izquierda y los valores más altos de la derecha a la derecha.

Además, tenga en cuenta que la suposición inteligente era solo elegir el elemento más correcto de una subsist. Esa no es la mejor suposición inteligente. Por otro lado, la solución (para suposición inteligente) no es escanear toda la lista dada! - Vea a continuación las mejores opciones.

Código de clasificación rápida en C

Aunque el valor más derecho se ha elegido para cada subsists anterior, convencionalmente, es el valor más a la izquierda el que se elige. Incluso cuando se hace una suposición más inteligente, el valor adivinado tendrá que colocarse en la posición más izquierda; y el valor izquierdo que estaba allí se colocará en alguna otra posición apropiada (aún en la lista).

Hay cuatro funciones C con los nombres, swap (), pivot (), partition () y Quicksort (). Quicksort (), la función, se codifica de manera recursiva, y llama a las otras funciones.

La función swap ()
Esta función intercambia dos elementos de matriz, utilizando sus índices. Es:

Swap void (char a [], int m, int n)
char temp = a [m];
A [m] = a [n];
A [n] = temp;

Una función simple pivot ()
Esta función elige entre el elemento más izquierdo y el elemento más derecho de la lista completa dada. Pone el menor de cualquiera de los dos en la posición más izquierda y el más grande en la posición más derecha. Es:

Void Pivot (char a [], int izquierdo, int right)
if (a [izquierda]> a [derecha])
intercambio (a, izquierda, derecha);

Esto es mejor que solo elegir el elemento más adecuado para la lista y las sub-listas, como se hizo anteriormente. A continuación se da una función Pivot () aún mejor.

Una función de partición ()
Así como la función Pivot () se puede escribir de diferentes maneras, la función PARTITION () se puede escribir de diferentes maneras. El elegido para este artículo es:

Int Partition (char a [], int izquierdo, int right)
int pivot = a [izquierda];
int i = izquierda;
int j = derecho + 1;
hacer
do ++ i;
mientras (a [i] pivote);
si yo < j)
intercambio (a, i, j);
mientras yo < j);
intercambio (a, j, izquierda);
regresar j;

Después de colocar el elemento pivote en la posición más a la izquierda de la lista o la subsist, por la función Pivot (), la función de partición escanea la lista o la subsist desde ambos extremos, intercambiando los elementos que no están en el lado correcto del pivote. El escaneo desde el extremo izquierdo comienza después del pivote del extremo más izquierdo (de la lista o la subsist); Porque el pivote se cambiará al final ("do ++ i;" arriba).

El índice de retorno, j, es la nueva (siguiente) posición de pivote.

La función QuickSort ()
Esta es una función recursiva que llama a las otras funciones. Es:

void Quicksort (char a [], int izquierdo, int right)
Si (izquierda < right)
pivote (a, izquierda, derecha);
int k = partición (a, izquierda, derecha);
Quicksort (A, izquierda, K-1);
Quicksort (a, k+1, derecha);

Aquí, K es lo mismo que J devuelto arriba.

Todas las funciones anteriores codificadas juntas, en el orden descrito, formarán el programa QuickSort.

La función principal C

Una función principal C adecuada para probar el programa es:

int main (int argc, char ** argv)

char a [] = "Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P";
int sz = sizeof (a)/sizeof (a [0]);
Quicksort (A, 0, SZ-1);
para (int i = 0; iprintf ("%c", a [i]);
printf ("\ n");
regresar 0;

La función QuickSort () apropiada se llama desde la función principal C, pasando la matriz como el primer argumento. El segundo argumento que queda es un índice, 0, de toda la lista. El tercer argumento, derecho, es el último pero un índice de toda la lista.

Pivote mediano

Si se organizan tres números diferentes en orden ascendente, entonces la mediana es el valor medio (segundo). Una mejor manera que la anterior, para obtener el pivote, es buscar la mediana, entre el valor más a la izquierda, el valor medio de la lista o la subsist, y el valor más a la derecha. El código es:

int midIndex = (izquierda + derecha) / 2; // número entero tomado
if (a [MidIndex] < A[left])
intercambio (a, izquierda, middex);
if (a [derecho] < A[left])
intercambio (a, izquierda, derecha);
if (a [MidIndex] < A[right])
intercambio (A, MidIdex, derecha);
char pivot = a [derecho];

Observe que los tres elementos podrían haber cambiado de posición. Este código se combina con la función Pivot () anterior para tener:

Void Pivot (char a [], int izquierdo, int right)
// Obtener la mediana
int midIndex = (izquierda + derecha) / 2; // número entero tomado
if (a [MidIndex] < A[left])
intercambio (a, izquierda, middex);
if (a [derecho] < A[left])
intercambio (a, izquierda, derecha);
if (a [MidIndex] pivote)
intercambio (a, izquierda, derecha); // de lo contrario, un [izquierdo] es el pivote

Tenga en cuenta la última condición if.

Conclusión

El sillón rápido es una división y conquista el algoritmo de clasificación. Sigue dividiendo (particionando) la lista en tres sub-listas recursivamente. La subplave media siempre consiste en un elemento, que es el pivote. Al hacer el pivote, la clasificación se realiza en un sentido amplio en esa etapa. Sin embargo, a medida que continúa la recursión, se obtiene una clasificación perfecta al final del programa.