Ordenamiento rapido o quickSort

Editar 0 8
ALGORITMO DE ORDENAMIENTO RAPIDO O QUICKSORT

Este algoritmo esta basado en la tecnica divide y vencers (consiste en dividir el problema en
pequeos subproblemas mas sencillos para luego estos ser resueltos con un calculo mas
sencillo) asi crearemos arreglos mas pequeos para ordenar estos.

Los pasos que realiza este algoritmo son:

1. Selecciona un valor del arreglo como pivote es decir un numero por el cual todos los elementos
van a ser comparados.
2. se realizan dos bsquedas: una de izquierda a derecha, buscando un elemento
mayor que el pivote, y otra de derecha a izquierda, buscando un elemento menor
que el pivote. Cuando se han encontrado los dos, se intercambian, y se sigue
realizando la bsqueda hasta que las dos bsquedas se encuentran.
3. luego se organizan los subarreglos que quedaron a mano derecha y izquierda.


Ejemplo:

Tenemos un arreglo que esta definido con los valores {22,40,4,10,12,35} los pasos en quicksort
para arreglarlo son los siguientes:

1. se toma como pivote el numero 22 recuerden puede ser cualquier numero.
2. la bsqueda de izquierda a derecha encuentra el valor 40 que es mayor a pivote y la bsqueda
de derecha a izquierda encuentra el valor 35 no lo toma porque es mayor a el numero pivote
(recuerden que la bsqueda de derecha a izquierda busca los menores) entonces continua y
encuentra a 12 que es menor que el pivote y se intercambian el resultado seria
{21,12,4,10,40,35}
3. si seguimos la bsqueda la primera encuentra el valor 40, y la segunda el valor 10,pero ya se
han cruzado,as que paramos. Para terminar la divisin, se coloca el pivote en su lugar el
numero encontrado por la segunda busqueda, el 10 quedando: {10,12,4,22,40,35}
4. ahora tenemos dividido el arreglo en dos arreglos mas pequeos que son {10,12,4} y el {40,35},
y en ellos se repetir el mismo proceso.

PSEUDOCODIGO


Principal
variables A: arreglo[1..100] entero
variables i,j,central:entero
variables primero, ultimo: entero
para i = 1 hasta 100
leer(A[i])
Fin para
primero = 1
ultimo = 100
qsort(A[],100)
Fin
Funcion qsort(primero, ultimo:entero)
i = primero
j = ultimo
central = A[(primero,ultimo) div 2]
repetir
mientras A[i]
j = j - 1
fin mientras
si i < = j
aux = A[i]
A[j] = A[i]
A[i] = aux
i = i + 1
j = j - 1
fin si
hasta que i > j
si primero < j
partir(primero,j)
fin si
si i < ultimo
partir(i, ultimo)
fin si
fin funcion qsort



IMPLEMENTACION EN JAVA


public void ordenarQuicksort(int[] vector, int primero, int ultimo){
int i=primero, j=ultimo;
int pivote=vector[(primero + ultimo) / 2];
int auxiliar;
do{
while(vector[i]<pivote) i++;
while(vector[j]>pivote) j--;
if (i<=j){
auxiliar=vector[j];
vector[j]=vector[i];
vector[i]=auxiliar;
i++;
j--;
}
} while (i<=j);
if(primero<j) ordenarQuicksort(vector,primero, j);
if(ultimo>i) ordenarQuicksort(vector,i, ultimo);
}

AQUI LES DEJO UN VIDEO PARA QUE PUEDAN VER MEJOR LA FORMA DE
COMPARACION QUE USA EL QUICKSORT ESPERO QUE SEA DE SU COMPRENSION
ESTA VERSION VISUAL DE COMO FUNCIONA ESTE ORDENAMIENTO!!!


MIS ALGORITMOS
El ordenamiento rpido (quicksort en ingls) es un algoritmo basado en la
tcnica de divide y vencers, que permite, en promedio, ordenar n elementos
en un tiempo proporcional a n log n. Esta es la tcnica de ordenamiento ms
rpida conocida. Fue desarrollada por C. Antony R. Hoare en 1960. El
algoritmo original es recursivo, pero se utilizan versiones iterativas para mejorar
su rendimiento (los algoritmos recursivos son en general ms lentos que los
iterativos, y consumen ms recursos).
El algoritmo fundamental es el siguiente:
Elegir un elemento de la lista de elementos a ordenar, al que llamaremos
pivote.
Resituar los dems elementos de la lista a cada lado del pivote, de manera
que a un lado queden todos los menores que l, y al otro los mayores. En
este momento, el pivote ocupa exactamente el lugar que le corresponder
en la lista ordenada.
La lista queda separada en dos sublistas, una formada por los elementos a
la izquierda del pivote, y otra por los elementos a su derecha.
Repetir este proceso de forma recursiva para cada sublista mientras stas
contengan ms de un elemento. Una vez terminado este proceso todos los
elementos estarn ordenados. Como se puede suponer, la eficiencia del
algoritmo depende de la posicin en la que termine el pivote elegido.
En el mejor caso, el pivote termina en el centro de la lista, dividindola en
dos sublistas de igual tamao. En este caso, el orden de complejidad del
algoritmo es O(nlog n).
En el peor caso, el pivote termina en un extremo de la lista. El orden de
complejidad del algoritmo es entonces de 0(n). El peor caso depender de
la implementacin del algoritmo, aunque habitualmente ocurre en listas que
se encuentran ordenadas, o casi ordenadas.
En el caso promedio, el orden es O(nlog n).
No es extrao, pues, que la mayora de optimizaciones que se aplican al
algoritmo se centren en la eleccin del pivote.
Pseudocdigo
inicio
variables A: arreglo[1..100] entero
variables i,j,central:entero
variables primero, ultimo: entero
para i = 1 hasta 100
leer(A[i])
Fin para
primero = 1
ultimo = 100
qsort(A[],100)
Fin

Funcion qsort(primero, ultimo:entero)
i = primero
j = ultimo
central = A[(primero,ultimo) div 2]
repetir
mientras A[i]central
j = j - 1
fin mientras
si i < = j
aux = A[i]
A[j] = A[i]
A[i] = aux
i = i + 1
j = j - 1
fin si
hasta que i > j
si primero < j
partir(primero,j)
fin si
si i < ultimo
partir(i, ultimo)
fin si
fin funcion qsort
Diagrama de flujo Ordenamiento
rpido