Definicin:

El algoritmo Quicksort o tambin llamado algoritmo de ordenamiento rpido, es un algoritmo de

ordenamiento de datos, que usa recursividad para poder ordenarlo, adems que hace comparaciones
entre un pivote seleccionado y sus dems elementos del arreglo, y va recorriendo dos contadores que
indican la posicin de dos elementos uno inicial y un final, y de acuerdo a las comparaciones hace un
intercambio entre los valores de estos contadores.
-Es un algoritmo como su nombre lo dice rpido pues es el mas rpido de los algoritmos de ordenacin,
ya que hace menos comparaciones.
- Usa la tcnica Divide y Vencers, la cual divide el arreglo en partes mas pequeas, usando la
recursividad.
- Su tiempo de ejecucin promedio es O(nlog2n). .
- Su tiempo de ejecucin en el pero caso es de O(n^2).

Para este algoritmo el pivote usado es el de posicin (primero+ultimo)/2

CDIGO

#include <iostream>

1 std::cout;

using std::endl;

#include <iomanip>

using std::setw;

#include <cstdlib>

#include <ctime>

const int tamano = 10, MAXIMO = 1000;

void quicksort( int * const, int, int );

void swap( int * const, int * const );

int main()

int arregloAordenar[ tamano ] = { 0 };

int loop;

srand( time( 0 ) );

for ( loop = 0; loop < tamano; ++loop )

arregloAordenar[ loop ] = rand() % MAXIMO;

 cout << "Los valores del arreglo antes de ordenarse son:\n";

for ( loop = 0; loop < tamano; ++loop )

cout << setw( 4 ) << arregloAordenar[ loop ];

cout << "\n\n";

if ( tamano == 1 )

cout << "El arreglo esta ordenado: " << arregloAordenar[ 0 ] << '\n';

else {

quicksort( arregloAordenar, 0, tamano - 1 );

cout << "Los valores del arreglo ordenado son:\n";

for ( loop = 0; loop < tamano; ++loop )

cout << setw( 4 ) << arregloAordenar[ loop ];

cout << endl;

return 0;

void quicksort( int * const arreglo, int first, int last )

int particion( int * const, int, int );

int posicionActual;

if ( first >= last )

return;

posicionActual = particion( arreglo, first, last );

quicksort( arreglo, first, posicionActual - 1 );

quicksort( arreglo, posicionActual + 1, last );

int particion( int * const arreglo, int izquierda, int derecha )

int posicion = izquierda;

while ( true ) {
 while ( arreglo[ posicion ] <= arreglo[ derecha ] && posicion != derecha )

--derecha;

if ( posicion == derecha )

return posicion;

if ( arreglo[ posicion ] > arreglo[ derecha ]) {

swap( &arreglo[ posicion ], &arreglo[ derecha ] );

posicion = derecha;

while ( arreglo[ izquierda ] <= arreglo[ posicion ] && izquierda != posicion )

++izquierda;

if ( posicion == izquierda )

return posicion;

if ( arreglo[ izquierda ] > arreglo[ posicion ] ) {

swap( &arreglo[ posicion ], &arreglo[ izquierda ] );

posicion = izquierda;

void swap( int * const ptr1, int * const ptr2 )

int temp;

temp = *ptr1;

*ptr1 = *ptr2;

*ptr2 = temp;

*****QuickSort Ordenamientos*****

#include<iostream>
#include<conio.h>
#define MAX 50

using namespace std;
void LeerArreglo(int,int []);
void Quicksort(int [],int,int);
void MuestraArreglo(int,int []);

int main(void)
{
system("color 0a");
int Numeros[MAX];
int n;
cout<<"\t****************************************************\n";
cout<<"\t*** ALGORITMO DE ORDENAMIENTO QUICKSORT ***\n";
cout<<"\t*** ----------------------------------- ***\n";
cout<<"\t****************************************************\n\n\n";

cout<<"\n\nNUMERO DE DATOS A LEER:"; cin>>n;

LeerArreglo(n,Numeros); //ingreso de datos en array

Quicksort(Numeros,0,n-1); // '0' es el primer elemento y n-1 es ultimo
cout<<endl<<"\n\n LOS ELEMENTOS FUERON ORDENADOS \n\n"<<endl;
MuestraArreglo(n,Numeros);//muestra array ordenado

getch();
return 0;
}

void Quicksort(int arreglo[],intprimero, int ultimo)

{ int i,j,aux, pivote;
i=primero;
j=ultimo;
pivote=arreglo[(primero+ultimo)/2];//es el elemento medio del arreglo
do {

while(pivote>arreglo[i])
i++;
while(pivote<arreglo[j])
j--;
if(i<=j)
{ aux=arreglo[i];
arreglo[i]=arreglo[j];
arreglo[j]=aux;
i++;
j--;
}
}while(i<=j);
if(primero<j)
 Quicksort(arreglo,primero,j);
if(ultimo>i)
Quicksort(arreglo,i,ultimo);

void LeerArreglo(int n,int array[])

{ for(int i=0; i<n; i++)
{cout<<"\n INGRESE ELEMENTO ["<<i<<"]: "; cin>>array[i];}
}

void MuestraArreglo(int n, intarray[])

{int i;
for(i=0; i<n; i++)
cout<<"["<<array[i]<<"] ";
}