2012

Algoritmos de ordenamiento recursivo
Implementación en C++
Universidad Autónoma del Estado de Hidalgo Instituto de Ciencias Básicas e Ingeniería Estructura de Datos II

Salvador Andrade Raúl Lic. Sistemas Computacionales 21/09/2012

....................... 3 Objetivo .............................................. 4 MERGESORT ........................................................................................... 8 Bibliografía ....... 3 QUICKSORT ................................................................................................................................Contenido Introducción ................................... 6 Conclusion .................................................................................................................................................................................................. 5 Desarrollo ................... 8 ............................................................................................................................................................................................................................................................................................................................................................................................................................................

Introducción Es mucho más fácil. . operar la información cuando esta se encuentra almacenada siguiendo cierto orden. la búsqueda de un elemento particular puede hacerse de manera tan eficiente como O(log n). usando búsqueda binaria. cuando tenemos una lista ordenada de n elementos. Objetivo Entender y comprender el funcionamiento del algoritmo quicksort. Por ejemplo. y rápido que es lo que realmente nos importa.

R. Lo llamaremos elemento de división.A. Buscas la posición que le corresponde en la lista ordenada (explicado más abajo). al que llamaremos contador por la izquierda. Fue desarrollada por C. Se utilizan dos índices: i. Al finalizar este procedimiento el elemento de división queda en una posición en que todos los elementos a su izquierda son menores que él. de manera que a un lado queden todos los menores que él y al otro los mayores (explicado más abajo también). Reflexionando un poco más se obtiene un procedimiento mucho más efectivo. porque sabemos que a un lado los elementos son todos menores y al otro son todos mayores (o habrían sido intercambiados). El algoritmo fundamental es el siguiente:    Eliges un elemento de la lista. Repites esto hasta que se crucen los índices.  Una idea preliminar para ubicar el elemento de división en su posición final sería contar la cantidad de elementos menores y colocarlo un lugar más arriba. El algoritmo original es recursivo. Puede ser cualquiera (en Optimizando veremos una forma más efectiva). para que se cumpla la condición y pueda aplicarse la recursividad. al que llamaremos contador por la derecha. y consumen más recursos). y j. El algoritmo es éste:     Recorres la lista simultáneamente con i y j: por la izquierda con i (desde el primer elemento). y por la derecha con j (desde el último elemento). Acomodas los elementos de la lista a cada lado del elemento de división. El punto en que se cruzan los índices es la posición adecuada para colocar el elemento de división. pero se utilizan versiones iterativas para mejorar su rendimiento (los algoritmos recursivos son en general más lentos que los iterativos. y los que están a su derecha son mayores. Cuando lista[i] sea mayor que el elemento de división y lista[j] sea menor los intercambias. Pero luego habría que mover todos estos elementos a la izquierda del elemento. En este momento el elemento de división separa la lista en dos sublistas (de ahí su nombre). . Realizas esto de forma recursiva para cada sublista mientras éstas tengan un largo mayor que 1. Hoare en 1960.QUICKSORT Esta es probablemente la técnica más rápida conocida. Una vez terminado este proceso todos los elementos estarán ordenados.

. que ya están ordenados.6 Recursión sigue considerando un procedimiento equivalente para ordenar las 12 cartas de un palo de la baraja de cartas. . ordenar por fusión el segundo grupo de 6 cartas.MERGESORT Vamos a estudiar ahora un método recursivo de ordenación de vectores: mergesort (que se podría traducir por ordenación por fusión o mezcla). Ordenar un grupo de 1 sola carta es trivial: ¡siempre está ordenado! . ¿no? Para ordenar 12 cartas por fusión hemos de ordenar dos grupos de 6 cartas por fusión. ordenar por fusión el primer grupo de 6 cartas. Ya ves dónde aparece la recursión. tomando siempre la carta con número menor de cualquiera de los dos grupos (que siempre será la primera de uno de los dos grupos). ¿Cuándo finaliza la recursión? Cuando nos enfrentemos a casos triviales. Estudiemos primero la aproximación que Introducción a la Programación con C 1913. La ordenación por fusión de un palo de la baraja consiste en lo siguiente: Dividir el paquete de cartas en dos grupos de 6 cartas. Y para ordenar cada grupo de 6 cartas por fusión tendremos que ordenar dos grupos de 3 cartas por fusión. fundir los dos grupos. Y para ordenar 3 grupos de cartas por fusión.

T pivote. } i = primero. a[j] = aux. { return 0. * * Compilado con g++ (Ubuntu/Linaro 4. if(i < ultimo) central = (primero+ultimo)/2. pivote = a[central]. central. for(int k = primero. -4. primero. ".3-1ubuntu5) 4. i. cout << endl << a [central] quicksort(a. using namespace std. i++. 19. template <class T> } void quicksort(T a[]. 92. 16}. k < 6. quicksort(a. 15. primero. << endl << endl.Desarrollo /*------------------------------------------------------------* Algoritmos de ordenamiento (recursivos) * * Desarrollado por:Salvador Andrade Raúl * 5to 2 ICBI B UAEH Pachuca Hgo.3 -------------------------------------------------------------*/ #include <iostream> a[i] = a[j]. cout << endl << endl. 6). k++) int main(){ cout << a[k] << " :: float a[]={2. 6. quicksort(a. j--. int }while(i < j). cout << a[k] << " ".6. } aux = a[i]. k++) while(a[i] < pivote) i++. 1.6. ultimo). while(a[j] > pivote) j--. k <= ultimo. j). int ultimo){ if(primero < j) int i . j = ultimo. j . 14. . if(i <= j) cout << endl << endl. 0. do{ for(int k = 0. T aux.

} x = z = izqda. primero. z. int der){ central. int return 0. while(y <= der) tmp[z++] = a[y++]. primero. central +1. ultimo). y. . } cout << endl <<endl << "Ordenado: ".6. 4. cout << "Arreglo original: ".6. 6}. T tmp[M]. for(z = izqda. template <class T> mostrar(a). primero. } int x. } main(){ while(x <= medio) int a[]={9. mostrar(a). void mostrar (int a[]){ while(x <= medio && y <= cout << endl << endl. 5. i++){ if(a[x] <= a[y]) cout << a[i] << " ". z <= der. using namespace std. i < 7. int mezcla(a. z++) mergesort(a. tmp[z++] = a[x++]. 7). 1. tmp[z++] = a[x++]. medio. } else } tmp[z++] = a[y++]. a[z] = tmp[z]. void mergesort (T a[]. int izqda. 10. int ultimo){ } int central. 0. * * Compilado con g++ (Ubuntu/Linaro 4. void mezcla(T a[]. der){ for (int i=0. mergesort(a.3 -------------------------------------------------------------*/ if(primero < ultimo){ central = (primero + #include <iostream> ultimo)/2. central).3-1ubuntu5) 4. 3. y = medio + 1./*------------------------------------------------------------* Algoritmos de ordenamiento y busqueda en un arreglo dinamico * * Desarrollado por:Salvador Andrade Raúl * 5to 2 ICBI B UAEH Pachuca Hgo. mergesort(a. template <class T> ultimo).

mergesort por ser algoritmos de ordenación recursiva son más rápidos. pero muchas veces no los mas óptimos en la utilización de los recursos cuando ya se trabaja con cantidades de información muy grandes.com/p/kRe/ Ordenamiento Rápido (Quicksort).conclase. Algoritmos de ordenamiento.Conclusion Quicksort. Bibliografía  Introducción a la programación con C. recuperado el 09 de octubre de 2012 de http://c. Andrés Marzal Isabel Gracia Departamento de Lenguajes y Sistemas Informáticos.net/orden/?cap=quicksort  . recuperado el 09 octubre de 2012 de http://ubuntuone.

Sign up to vote on this title
UsefulNot useful