Algoritmo Quicksort

Quiero Descargar Un libro gratis

El algoritmo Quicksort es un algoritmo de ordenamiento recursivo que divide la lista de elementos a ordenar en dos
sub-listas más pequeñas, una que contiene los elementos menores que un valor elegido como ”pivote” y otra que contiene
los elementos mayores que el pivote. Luego, se aplica el mismo proceso de forma recursiva en cada sub-lista hasta que se
ordenen todos los elementos. El pivote puede elegirse de varias formas, siendo la más común elegir el primer elemento de la
lista. El algoritmo Quicksort es muy eficiente para listas grandes y se utiliza ampliamente en la práctica.

Codigo
Este programa ordena un vector con 10,000 elementos al azar, que van del 0 hasta el 5,000

C++

#include<iostream>
#include<cstdlib>
#include <chrono>
using namespace std::chrono;
using namespace std;
const int elementos=10000;

void crear_lista(int *lista){

for (int i=0; i<elementos; i++){
lista[i]=rand()%5000;
}
}

int dividir(int *array, int inicio, int fin){

int izq;
int der;
int pibote;
int temp;

pibote = array[inicio];
izq = inicio;
der = fin;
while (izq < der){
while (array[der] > pibote){
der--;
}

while ((izq < der) && (array[izq] <= pibote)){

izq++;
}

if(izq < der){

temp= array[izq];
array[izq] = array[der];
array[der] = temp;
}
}

temp = array[der];
array[der] = array[inicio];
array[inicio] = temp;

return der;
}

void quicksort(int *array, int inicio, int fin){

int pivote;
if(inicio < fin)
{
pivote = dividir(array, inicio, fin );
quicksort( array, inicio, pivote - 1 );
quicksort( array, pivote + 1, fin );

1
 }
}

int main (int argc, char *argv[])

{
int lista[elementos];
srand((unsigned) time(NULL));
auto start = high_resolution_clock::now();
crear_lista(lista);
auto stop = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop - start);
for (int i=0; i<100; i++) {
cout<<lista[i]<<" ";
}
cout<<"\n";
cout << duration.count() << " microsegundos para crear la lista \n";
cout<<"||||||||||||||||||||||||||||||||||||||||||||||||\n";

auto start2 = high_resolution_clock::now();

int comparaciones=0;
int cambios=0;
quicksort(lista,0,elementos-1);
auto stop2 = high_resolution_clock::now();
auto duration2 = duration_cast<microseconds>(stop2 - start2);
cout<<"Se hicieron " << comparaciones <<" comparaciones\n";
cout<<"Se hicieron " << cambios <<" cambios\n";
for (int i=0; i<100; i++) {
cout<<lista[i]<<" ";
}
cout<<"\n";
cout << duration2.count() << " microsegundos para ordenar la lista\n";
return 0;
}

Que hace cada variable

elementos: es una constante que indica el número de elementos que contendrá la lista a ordenar.

crear lista: recibe como argumento un puntero a un arreglo de enteros y llena ese arreglo con números aleatorios
generados por la función rand().

dividir: recibe como argumentos un arreglo de enteros, un ı́ndice de inicio y un ı́ndice de fin. La función toma el primer
elemento del arreglo como pivote y reorganiza el arreglo para que todos los elementos menores que el pivote estén a su
izquierda y todos los mayores a su derecha, devolviendo el ı́ndice del pivote.

quicksort: recibe como argumentos un arreglo de enteros, un ı́ndice de inicio y un ı́ndice de fin. La función llama a
”dividir” para obtener el ı́ndice del pivote, luego aplica la misma estrategia de forma recursiva a las sub-listas a la izquierda
y a la derecha del pivote hasta que se ordenen todos los elementos.

main: crea un arreglo de enteros llamado ”lista”, inicializa la semilla del generador de números aleatorios con el tiempo
actual y mide el tiempo que tarda en llamar a la función ”crear lista” para llenar el arreglo. Luego, mide el tiempo que
tarda en llamar a la función ”quicksort” para ordenar el arreglo y muestra el número de comparaciones y cambios realizados
durante el proceso, ası́ como el tiempo que tardó.

Resultados
El programa anterior fue ejecutado 5 veces y de estas veces saque los promedios de cada variable y estos fueron los
reultados.

Operacion Unidades
Crear lista 939 microsegundos
Ordenar Lista 1127 microsegundos
Operaciones 32347
2
 Conclusiones
El algoritmo de ordenamiento de quicksort es mucho más rapido que cualquier otro algortimo, pero tambien más complejo
de implementar