Tiempo de ejecucion de particiones (quicksort)

Particiones de método de
ordenamiento quicksort

Oliver a. vilca huayta

COLQUEHUANCA RODRIGO, Linio

091161

PARTICIONES DE ORDENAMIENTO QUICKSORT

I. INTRODUCCION
Los computadores se emplean frecuentemente para almacenar y recuperar
grandes volúmenes de datos. Con su velocidad y facilidad de acceso, los
computadores aventajan a otros medios de almacenamiento como el papel
y las microfichas.

Es importante estudiar la forma en que los computadores pueden
almacenar los datos, de modo que su recuperación (búsqueda) sea rápida.
Para lograr esto, y puesto que usualmente los usuarios requieren que los
datos recuperados cuenten con algún orden particular, también es
importante estudiar algoritmos para ordenar los datos almacenados.
Para el caso del ordenamiento, el problema consiste en ordenar el vector
en forma ascendente (de menor a mayor). Si se quisiera trabajar con
ordenamiento descendente los cambios serían mínimos.
En este trabajo se verá el algoritmo de ordenamiento Quicksort
especialmente sus PARTICIONES que pueden ser implementadas de
diferentes formas que difieren entre sí en cuanto a su complejidad y
eficiencia.

2

II. ORDENAMIENTO

Uno de los procedimientos más comunes y útiles en el procesamiento de
datos, es la clasificación u ordenación de los mismos. Se considera ordenar
al proceso de reorganizar un conjunto dado de objetos en una secuencia
determinada. Cuando se analiza un método de ordenación, hay que
determinar cuántas comparaciones e intercambios se realizan para el caso
más favorable, para el caso medio y para el caso más desfavorable.

La colocación en orden de una lista de valores se llama Ordenación. Por
ejemplo, se podría disponer una lista de valores numéricos en orden
ascendente o descendente, o bien una lista de nombres en orden
alfabético. La localización de un elemento de una lista se llama búsqueda.
Tal operación se puede hacer de manera más eficiente después de que la
lista ha sido ordenada.

Existen varios métodos para ordenamiento, clasificados en tres formas:
 Intercambio
 Selección
 Inserción.

En cada familia se distinguen dos versiones: un método simple y directo,
fácil de comprender pero de escasa eficiencia respecto al tiempo de
ejecución, y un método rápido, más sofisticado en su ejecución por la
complejidad de las operaciones a realizar, pero mucho más eficiente en
cuanto a tiempo de ejecución. En general, para arreglos con pocos
elementos, los métodos directos son más eficientes (menor tiempo de
ejecución) mientras que para grandes cantidades de datos se deben
emplear los llamados métodos rápidos.

3

III. QUICKSORT
El método Quicksort basa su estrategia en la idea intuitiva de que es más
fácil ordenar una gran estructura de datos subdividiéndolas en otras más
pequeñas introduciendo un orden relativo entre ellas. En otras palabras, si
dividimos el array a ordenar en dos subarrays de forma que los elementos
del subarray inferior sean más pequeños que los del subarray superior, y
aplicamos el método reiteradamente, al final tendremos el array inicial
totalmente ordenado. Existen además otros métodos conocidos, el de
ordenación por montículo y el de shell.

El algoritmo Quicksort fue desarrollado en 1962 por C.A.R. Hoare, antes de
que se implementaran los primeros lenguajes con capacidad para ejecutar
funciones recursivas.

3.1 Complejidad computacional del Quicksort:
En el mejor de los casos tiene un costo de O(n*log (n)). Que es cuando
el pibote siempre queda al medio del arreglo.

Quicksort Mejor caso

En el peor de los casos tiene un costo de O(n^2). Cuando el pibote
siempre se inclina hacia a un lado, es decir, genera una array de sólo 1
elemento y una segunda con el resto de elementos.

Quicksort peor caso

4

En el caso promedio también tiene un costo de O(n*log (n)). Se
produce cuando el pibote se inclina más hacia un lado y los 2 subarrays
tienen distinto tamaño de elementos.

Quicksort caso promedio

Para calcular el tiempo de ejecución estoy usando la función clock() que
determina el tiempo usado por el procesador. En este caso defino 3
variables ini, final y total.
1ini=clock(); // Antes del quicksort:
2final = clock(); //Después que se ejecuta el quicksort
3total =((double)(final – ini)) /
4CLOCKS_PER_SEC; // El valor retornado por clock()
5debe ser dividido por el valor de la macro CLOCKS_PER_SEC

IV. Partición de método Cormen
Se tiene una array de n elementos, tomamos un valor del array como pivote
(usualmente el ultimo), separamos los elementos menor a este pivote a la
izquierda y los mayores a la derecha, es decir, dividimos el array en 2
subarrays.

5

int PartitionCormen(double A[], int left,int right){
double pivote;
int i,j;
pivote = A[right];
i = left - 1;
for( j=left; j<=right-1; j++){
if(A[j]<pivote){
i++;
swap(A[i],A[j]);
}
}
swap(A[i+1],A[right]);
return i+1;
}

V. Partición de método Cormen modificado
Se tiene una array de n elementos, tomamos un valor del array como pivote
el primero, separamos los elementos menor a este pivote a la izquierda y
los mayores a la derecha, es decir, dividimos el array en 2 subarrays.

int PartitionCormenModificado(double A[], int left,int right){
double pivote;
int i,j;
pivote = A[left];
i = right + 1;
for( j=right; j>=left+1; j--){
if(A[j]<pivote){
i--;
swap(A[i],A[j]);
}
}
swap(A[i-1],A[left]);
return i-1;
}

De manera que el árbol recursivo de ordenación queda más o menos así:

6

VI. Partición de método Brassard
Empezamos creando o generando un array de n elementos, por ejemplo yo
use la función rand() de c++ para generar aleatorios del 1 al 15:
a[] = {8, 1, 5, 14, 4, 15, 12, 6, 2, 11, 10, 7, 9};
izq der
0 1 2 3 4 5 6 7 8 9 10 11 12
8 1 5 14 4 15 12 6 2 11 10 7 9

Tomamos como pivote el 8 y usamos 2 índices que me indiquen la posición
del array: Uno que vaya de izquierda a derecha buscando los elementos
mayores al pivote. a[izq] Y un índice que busque de derecha a izquierda los
elementos menores al pivote. a[der] El índice izquierdo irá aumentando en
1 mientras el array en la posición izquierda sea menor o igual al pivote:
1while ((izq < der) && (array[izq] <= pibote)){
2 izq++;
3}

El índice derecho irá reduciéndose en 1 mientras el array en la posición
derecha sea mayor al pibote.
1while (array[der] > pibote){
2 der--;
3}

Si al final de estas 2 operaciones, el índice izquierdo es menor al derecho
se intercambian las posiciones a[izq] con a[der], usando una variable
temporal: En este caso, en la primer recorrido el índice izquierdo encuentra
al 14 (mayor al pivote) y el índice derecho al 7 (menor al pivote), y se
intercambian los índices:
8 1 5 14 4 15 12 6 2 11 10 7 9
8 1 5 7 4 15 12 6 2 11 10 14 9

Segundo recorrido: El índice izquierdo encuentra al 15 (mayor al pivote) y el
índice derecho al 2 (menor al pivote), se intercambian:
8 1 5 7 4 15 12 6 2 11 10 14 9
8 1 5 7 4 2 12 6 15 11 10 14 9

Tercer recorrido: El índice izquierdo encuentra al 12 (mayor al pivote) y el
índice derecho al 6 (menor al pivote), se intercambian:
8 1 5 7 4 2 12 6 15 11 10 14 9
8 1 5 7 4 2 6 12 15 11 10 14 9

7

Cuando los índices se juntan o se cruzan ponemos el pivote en el lugar que
le corresponde en el array:
1temp = array[der];
2array[der] = array[inicio]; // el pibote está en el inicio del
array
3array[inicio] = temp;

Se intercambian el 8 con el 6 y el array quedaría así:
6 1 5 7 4 2 8 12 15 11 10 14 9

int ParticionBrassard(double A[], int left, int right){
int pivote = A[left];
int izq = left - 1;
int der = right + 1;
while (izq < der){
do{
izq++;
} while (A[izq] < pivote);
do {
der--;
} while (A[der] > pivote);
if (izq < der){
swap(A[izq],A[der]);
}
}
return(der);
}

VII. Partición 4
int Particion4(int *v, int b, int t){
int i;
int pivote, valor_pivote;
int temp;
pivote = b;
valor_pivote = v[pivote];
for (i=b+1; i<=t; i++){
if (v[i] < valor_pivote){
pivote++;
temp=v[i];
v[i]=v[pivote];
v[pivote]=temp;
}
}
temp=v[b];
v[b]=v[pivote];
v[pivote]=temp;
return pivote;
}

8

VIII. Tiempo de ejecución de Particiones
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/times.h>
#include <sys/stat.h>
#include <math.h>
#include <string.h>
#include <unistd.h> // _SC_CLK_TCK The number of clock ticks per second;
#define Max_ind 32000
struct tms ti, tf, td;
double tsegundos,tsegundos2;
clock_t ta,tb,tc;
double Temp[Max_ind];
double tmp;
void IniT(){
ta=times(&ti);
printf("INI %f %fn", (double)(ti.tms_utime),(double)ta );
}
void FinT(){
tb=times(&tf);
printf("FIN %f %fn", (double)(tf.tms_utime),(double)tb );
td.tms_utime = tf.tms_utime-ti.tms_utime;
tc = tb - ta;
tsegundos =((double)(td.tms_utime))/sysconf(_SC_CLK_TCK);
tsegundos2 =((double)(tc))/sysconf(_SC_CLK_TCK);
printf("Pasaron = %lf %lf %lf n",(double)tc, tsegundos, tsegundos2);
}
int PartitionCormen(double A[], int left,int right){
double pivote,temp;
int i,j;
pivote = A[right];
i = left - 1;
for( j=left; j<=right-1; j++){
if(A[j]<pivote){
i++;
temp=A[i];
A[i]=A[j];
A[j]=temp;
}
}
temp=A[i-1];
A[i+1]=A[right];
A[right]=temp;
return i+1;
}
int PartitionCormenMod(double A[], int left,int right){
double pivote,temp;
int i,j;
pivote = A[left];
i = right + 1;
for( j=right; j>=left+1; j--){
if(A[j]<pivote){
i--;
temp=A[i];
A[i]=A[j];

9

A[j]=temp;
}
}
temp=A[i-1];
A[i-1]=A[left];
A[left]=temp;
return i-1;
}
int PartitionBrassard(double A[], int left, int right){
float temp;
int pivote = A[left];
int izq = left - 1;
int der = right + 1;
while (izq < der){
do{
izq++;
} while (A[izq] < pivote);
do {
der--;
} while (A[der] > pivote);
if (izq < der){
temp=A[izq];
A[der]=A[izq];
A[izq]=temp;
}
}
return(der);
}
int Partition4(int *v, int b, int t){
int i;
int pivote, valor_pivote;
int temp;
pivote = b;
valor_pivote = v[pivote];
for (i=b+1; i<=t; i++){
if (v[i] < valor_pivote){
pivote++;
temp=v[i];
v[i]=v[pivote];
v[pivote]=temp;
}
}
temp=v[b];
v[b]=v[pivote];
v[pivote]=temp;
return pivote;
}
main(int argc, char *argv[]){
int Nro_pruebas = 40;
int i,j,k,l;
double V1[Max_ind],V2[Max_ind],V3[Max_ind],V4[Max_ind],V5[Max_ind];
double C1[Max_ind],C2[Max_ind],C3[Max_ind],C4[Max_ind],C5[Max_ind];

10


for(i=0;i<Max_ind;i++){
V1[i]=random();V2[i]=random();V3[i]=random();V4[i]=random();
}
for(j=0;j<Max_ind;j++){
C1[j]=V1[j];C2[j]=V2[j];C3[j]=V3[j];C4[j]=V4[j];
}

IniT();
for(i=0;i<Nro_pruebas;i++){
k=PartitionCormen(C1,0,Max_ind-1);k=PartitionCormen(C2,0,Max_ind-1);
k=PartitionCormen(C9,0,Max_ind-1);k=PartitionCormen(C10,0,Max_ind-
1);
1);
1);
1);
1);
1);
}
FinT();

printf("n");
V1[j]=C1[j];V2[j]=C2[j];V3[j]=C3[j];V4[j]=C4[j];
}

IniT();
k=PartitionCormenMod(C1,0,Max_ind-
1);k=PartitionCormenMod(C2,0,Max_ind-1);

11

}
FinT();

printf("n");
}

IniT();
k=PartitionBrassard(C1,0,Max_ind-
1);k=PartitionBrassard(C2,0,Max_ind-1);
}
FinT();

printf("n");

12

}

IniT();
k=Partition4(C1,0,Max_ind-1);k=Partition4(C2,0,Max_ind-1);
}
FinT();

}

Prueba1

Prueba2

13

IX. Conclusión

35

30

25

20 Prueba 1
Prueba 2
15
Prueba 3

10

5

0
Cormen CormenMod Brassard Particion4

X. BIBLIOGRAFIA
Fundamentos de Algoritmia-Brassard
McGraw.Hill.Introduction.To.Algorithms.segunda.Edicion
http://es.wikipedia.org/wiki/Quicksort
http://c.conclase.net/

15

PARTICIONES DE ORDENAMIENTO QUICKSORT ........................................................... 2
I. INTRODUCCION ......................................................................................................... 2
II. ORDENAMIENTO ....................................................................................................... 3
III. QUICKSORT ........................................................................................................... 4
3.1 Complejidad computacional del Quicksort: ........................................................ 4
IV. Partición de método Cormen ............................................................................... 5
V. Partición de método Cormen modificado .............................................................. 6
VI. Partición de método Brassard ............................................................................. 7
VII. Partición 4 ............................................................................................................... 8
VIII. Tiempo de ejecución de Particiones ................................................................... 9
IX. Conclusión............................................................................................................ 15
X. BIBLIOGRAFIA ......................................................................................................... 15

16

Tiempo de ejecucion de particiones (quicksort)

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (15)

Similar a Tiempo de ejecucion de particiones (quicksort)

Similar a Tiempo de ejecucion de particiones (quicksort) (20)

Último

Último (20)

Tiempo de ejecucion de particiones (quicksort)