Método de Ordenamiento en C

1. POR:
JUAN ARPI &
ANDRÉ JARAMILLO

2. CONTENIDO
 INTRODUCCIÓN
 ORDEN DE COMPLEJIDAD
 ESTRATEGIA DE ORDENAMIENTO
 EJEMPLO DE EXPLICACIÓN
 PSEUDOCÓDIGO QUICK SORT
 CÓDIGO EN LENGUAJE C PARA VECTORES
 CÓDIGO EN LENGUAJE C PARA LISTAS LIGADAS
 VENTAJAS Y DESVENTAJAS
 DONDE SE IMPLEMENTA

3. INTRODUCCIÓN
• Quicksort es un algoritmo basado en la técnica de divide y vencerás, que
permite, en promedio, ordenar n elementos en un tiempo proporcional a
n log n.
• Este método fue creado por el científico británico Charles Antony
Richard Hoare en 1960
• Actualmente es el más eficiente y veloz de los métodos de ordenación
interna.

4. ORDEN DE COMPLEJIDAD
 ORDEN DE COMPLEJIDAD PARA EL MEJOR CASO
 ORDEN DE COMPLEJIDAD PARA EL PEOR CASO
 ORDEN DE COMPLEJIDAD PARA EL CASO
PROMEDIO

5. ESTRATEGIA DE ORDENAMIENTO
 El algoritmo quick sort básicamente consiste en
elegir un pivote y hacer comparaciones hasta que
los elementos mayores estén a la derecha y los
menores a la izquierda del pivote, hasta que el
pivote encuentra su lugar ordenado.
 Los elementos de la izquierda como los de la
derecha serán dos sub listas y se aplicara el
mismo proceso eligiendo un pivote a cada lista
hasta que cada pivote queda en un lugar
ordenado.
 Generalmente se escoge de pivote al primer
elemento.

6. EJEMPLO DE EXPLICACION:

9. Ejemplo Pseudocódigo
PROCEDURE Quicksort(VAR a:vector;prim,ult:CARDINAL);
VAR l:CARDINAL;
BEGIN
IF prim<ult THEN
l:=Pivote(a,a[prim],prim,ult);
Quicksort(a,prim,l-1); //recursividad
Quicksort(a,l+1,ult) //recursividad
END
END Quicksort;
PROCEDURE Pivote(VAR a:vector;p:INTEGER;prim,ult:CARDINAL)
VAR i,l:CARDINAL;
BEGIN
i:=prim; l:=ult+1;
REPEAT INC(i) UNTIL (a[i]>p) OR (i>=ult);
REPEAT DEC(l) UNTIL (a[l]<=p);
WHILE i<l DO
Intercambia(a,i,l);
REPEAT INC(i) UNTIL (a[i]>p);
REPEAT DEC(l) UNTIL (a[l]<=p)
END;
Intercambia(a,prim,l);
RETURN l
END Pivote;

10. Ejemplo Código C - Arreglo
void qs(int lista[],int limite_izq,int limite_der){
int izq,der,temporal,pivote;
izq =limite_izq;
der = limite_der;
pivote = lista[(izq+der)/2];
do{
while(lista[izq]<pivote && izq<limite_der)izq++;
while(pivote<lista[der] && der > limite_izq)der--;
if(izq <=der){
temporal= lista[izq];
lista[izq]=lista[der];
lista[der]=temporal;
izq++;
der--;
}
}while(izq<=der);
if(limite_izq<der){qs(lista,limite_izq,der);}
if(limite_der>izq){qs(lista,izq,limite_der);}
}
void quicksort(int lista[],int n){
qs(lista,0,n-1);
}
int main(int argc, const char * argv[]){
int i=0;
int lista[] = {100,56,0,1,-45,2,46,5,9,6,67,23,5};
int size = sizeof(lista)/sizeof(int);
printf("nntLista Desordenada n");
for ( i=0; i<size; i++) {
printf(" |%d|",lista[i]);
if(i<size-1)
printf(",");
}
quicksort(lista,size);
printf(“nntLista Ordenada nn");
for ( i=0; i<size; i++) {
printf(" |%d|",lista[i]);
if(i<size-1)
printf(",");
}
system("PAUSE");
return 0;
}

11. Ejemplo Código C – Lista ligada
Datos *quicksort(Datos *primero, Datos *ultimo, int
(*comp)(void*,void*)){
Dato *r, *p, *s, *t, *w, *u;
t = w = s = u = NULL; /*apùntadores a las sublistas*/
r = ultimo->sig; /*un apuntador al final para
engancharla de nuevo*/
p = primero->sig; /*el primer elemento para comparar*/
if (primero == ultimo) /*si la lista es solo un elemento
está ordenada*/
return primero;
while (p != r){ /*el loop que la separa en dos conjuntos*/
/*el primer elemento de la lista va a ser el elemento
pivot*/
if((*comp)(p, primero) < 0)
if(s == NULL)
t = s = p;
else {
s->sig = p;
s = s->sig;
}
else
if(u == NULL)
w = u = p;
else {
u->sig = p;
u = u->sig;
}
p = p->sig;
}
if (s == NULL){ /*si uno de los conjuntos estaba vacio*/
primero->sig = quicksort(w,u,comp); /*ordenamos el
otro conjunto*/
return primero;
}
if (u == NULL){/*lo mismo si el otro sub-conjunto
estaba vacio*/
s->sig = primero;
primero->sig = r;
return quicksort(t,s,comp);
}
s->sig = primero; /*si los dos estaban con datos los
enganchamos*/
u->sig = r;
primero->sig = quicksort(w,u,comp);
return quicksort(t, s,comp);
}

12. Ventajas y Desventajas
 Ventajas.
 Es el método de ordenamiento más rápido conocido.
 Usa la recursividad evitando el uso innecesario de código
masivo.
 Usa la estrategia de divide y vencerás, es decir aplica
paralelismo.
 Desventajas.
 Debe prestarse mucha atención para evitar que un pequeño
error de programación nos atrape en un bucle infinito.
 Es fuertemente dependiente de la “suerte”, es decir la
ubicación del pivote.

13. IMPLEMENTACION DE QUICK SORT
 Mostrar un listado ordenado del contenido de una
base de base de datos (p.ej. listado listado alfabético).
 Ordenar los resultados de una búsqueda en Internet
(p.ej. Google PageRank).
 Realizar una búsqueda.
 En estadística encontrar la mediana.
 Encontrar el par más cercano.
 Detectar duplicados.

14. PREGUNTAS ?

15. GRACIAS POR
SU ATENCION