Ordenacin rpida

Quicksort es un algoritmo de ordenacin rpida, que se utiliza no slo para fines

educativos, pero ampliamente aplicado en la prctica. En promedio, tiene O (n log n) la
complejidad, haciendo ordenacin rpida adecuada para clasificar grandes volmenes de
datos. La idea del algoritmo es bastante simple y una vez que te des cuenta, se puede
escribir tan rpido como quicksort ordenamiento de burbuja .

Algoritmo
La estrategia de divide y vencers se utiliza en ordenacin rpida. A continuacin de la
etapa de recursin se describe:
1.

Elija un valor de pivote. Tomamos el valor del elemento medio como valor de
pivote, pero puede ser cualquier valor, que est en el rango de valores ordenados,
incluso si no lo hace presente en la matriz.

2.

Particin. Reorganizacin de elementos de tal manera, que todos los elementos

que son menores que el pivote van a la parte izquierda de la matriz y todos los
elementos mayores que el pivote, vaya a la parte derecha de la matriz. Valores
iguales al pivote pueden alojarse en cualquier parte de la matriz. Observe, esa
matriz se puede dividir en partes no iguales.

3.

Ordenar las dos partes. Aplicar algoritmo quicksort recursivamente a la de las

partes izquierda y derecha.

algoritmo de particin en detalle

Hay dos ndices i y j y en el comienzo del algoritmo de particin i apunta al primer
elemento en la matriz apunta y J para el ltimo. Luego se mueve el algoritmo I hacia
adelante, hasta que se encuentre un elemento con valor mayor o igual que el pivote.
ndice j se mueve hacia atrs, hasta que un elemento con valor menor o igual que el
pivote se encuentra. Si i j entonces se intercambian y yo escalones hasta la siguiente
posicin (i + 1), j pasos a la anterior (j - 1). Algoritmo se detiene, cuando se hace mayor
que j.
Despus de la particin, todos los valores antes de la i-simo elemento es menos o igual
que el pivote y todos los valores despus de elemento j-simo es mayor o igual que el
pivote.
Ejemplo. Ordena {1, 12, 5, 26, 7, 14, 3, 7, 2} usando quicksort.

Aviso, que mostramos aqu slo el primer paso de recursin, con el fin de no hacer
demasiado largo ejemplo. Pero, de hecho, {1, 2, 5, 7, 3} y {14, 7, 26, 12} son ordenados
a continuacin, de forma recursiva.

Por qu funciona?
En el algoritmo de paso de particin divide la matriz en dos partes y cada elemento de una
de la parte izquierda es menor o igual que cada elemento b de la parte derecha. Tambin
ayb satisfacer a b pivote desigualdad. Despus de la terminacin de la recursin llama
tanto de las partes se convierten en ordenada y, teniendo en cuenta los argumentos
mencionados anteriormente, todo el conjunto est ordenada.

anlisis de complejidad
En la clasificacin rpida promedio tiene O (n log n) la complejidad, pero fuerte prueba
de este hecho no es trivial y no se presentan aqu. An as, se puede encontrar la prueba
en [1] . En el peor caso, clasificacin rpida se ejecuta O (n2), pero en la mayora de los
datos de "prcticas" funciona muy bien y supera a otros O (n log n) algoritmos de
ordenacin.

Fragmentos de cdigo
algoritmo de particin es importante per se, por lo tanto, puede llevarse a cabo como
una funcin separada. El cdigo para C ++ contiene la funcin slida para la
clasificacin rpida, pero el cdigo de Java contiene dos funciones separadas para la
particin y tipo, segn corresponda.
Java
particin int (int arr [], int izquierda, derecha int)
{
int i = izquierdo, J = derecha;
int tmp;
int = [(arr pivote izquierdo + derecho) / 2];

while (i <= j) {
mientras que (arr [i] <pivote)
i ++;
mientras que (arr [j]> pivote)

j--;
si (i <= j) {
tmp = arr [i];
arr [i] = arr [J];
arr [j] = tmp;
i ++;
j--;
}
};

i volver;
}

QuickSort vaco (int arr [], int izquierda, derecha int) {

int index = particin (arr, izquierda, derecha);
si (a la izquierda <ndice - 1)
QuickSort (arr, izquierda, ndice - 1);
si (ndice <derecha)
QuickSort (arr, ndice, derecha);
}

C ++
QuickSort vaco (int arr [], int izquierda, derecha int) {
int i = izquierdo, J = derecha;
int tmp;
int = [(arr pivote izquierdo + derecho) / 2];

/ * * Particin /
while (i <= j) {
mientras que (arr [i] <pivote)
i ++;
mientras que (arr [j]> pivote)
j -;
si (i <= j) {
tmp = arr [i];
arr [i] = arr [J];
arr [j] = tmp;
i ++;
j -;
}
};

/ * * Recursin /
si (a la izquierda <j)
QuickSort (arr, izquierda, j);
si (i <derecha)
QuickSort (arr, i, a la derecha);
}