HOJA DE TRABAJO PARA LA

PRÁCTICA 3: Algoritmos de
ordenamiento III
RadixSort

1. Eficiencia (1p)
Con respecto a 5.1 de P3:

1.- Crea una variable global, g_contador, de tipo entero.

2.- Incrementa g_contador inmediatamente después de la línea 14 en el Listado 1.
3.- Incrementa g_contador inmediatamente después de la línea 34 en el Listado 1.
4.- Imprime el valor de g_contador luego de realizar un ordenamiento.

Indica el valor teórico correspondiente a O( kn ) cuando n=4000, y k=4 valores posicionales

R: 16000.

Indica el número de operaciones que obtuviste en las corridas de tu programa cuando

n=4000 y k=4.
R: 16004.

¿El número de operaciones que obtuviste a qué se parece más, y porqué? O( kn ) o a O( n

log n ) (utiliza las líneas que sean necesarias):

R: El número que obtuve se asemeja mucho más a un orden O(kn), ya que al multiplicar el
número de elementos (4000) multiplicado por valor posicional (4), se obtiene 16000, lo que
es casi igual al resultado obtenido. de ser O(n log n) el resultado aproximado sería 50000.

2. Funciones (3p)
Nota que las siguientes funciones están encadenadas: si una está mal, el resto también.

void Radixsort(int list[],int tam,int numPos,int radix){

Queue* queues[radix];

for( int i = 0; i <= radix; ++i ){

queues[ i ] = Queue_New();
}

for(int i=1;i<=numPos;i++){
for(int j=0;j<tam;j++){
int whichQ=subKey(list[j],i,radix);
Queue_Enqueue(queues[whichQ],list[j]);

}
++g_contador;
collect(list,queues,radix);
 }
}

int subKey(int val,int pos,int radix){

int divisor=pow(10,pos-1);
return(val/divisor)%radix;
}

void collect(int list[], Queue* queues[],int radix){

int index=0;
int val;
for(int i=0;i<radix;i++){
while( Queue_IsEmpty( queues[i] ) == false ){
Item val;
Queue_Dequeue( queues[i], &val );
list[index]=val;
index++;
++g_contador;
}
}
}

3. Ejecución (1p)

.
CountingSort

4. Eficiencia (1p)
Con respecto a 5.2 de P3:

1.- Crea una variable global, g_contador, de tipo entero.

2.- Incrementa g_contador inmediatamente después de la línea 11 (u operación similar en
código C) en el Listado 2.
3.- Incrementa g_contador inmediatamente después de la línea 19 (u operación similar en
código C) en el Listado 2.
4.- Imprime el valor de g_contador luego de realizar un ordenamiento.

Indica el valor k correspondiente al rango [0,25].

R: 26 .

Indica el valor teórico correspondiente a O( k+n ) cuando n=5000, y siendo k el tamaño del
arreglo auxiliar (tienes que determinarlo).
R: el valor teórico sería 5000+k, para conocer “k” es necesario saber el rango con el que
estamos trabajando, pues ese valor corresponde al tamaño del arreglo auxiliar que
utilicemos, para el caso anterior k=26, pues en el rango [0,25] existen 26 “lugares”.

Indica el número de operaciones que obtuviste en alguna corrida de tu programa cuando

n=5000, y k representa el rango [0,25].
R: 5026.

Explica brevemente porqué este algoritmo tiene eficiencia en tiempo de O( k+n ) (utiliza las
líneas que sean necesarias):

R: Con este algoritmo no se realizan comparacion, lo que se hace es contar la frecuencia de

aparición de los valores, por lo que el arreglo solo es recorrido una vez, y después se
recorre el arreglo auxiliar (k), para copiar los elementos ordenados, por eso eso que su
eficiencia en tiempo es O(k+n), siendo n el número de elementos de la lista y k el tamaño
del arreglo auxiliar (que depende del rango con el que se trabaje).

5. Función counting_sort() de 6.2-6 (3p)

void counting_sort(int list[],int elems,int low,int high){
int capacity= high-low+1;
int* aux=calloc(capacity,sizeof(int));

for(int i=0;i<elems;i++){
int pos=list[i];
aux[pos]++;
++g_contador;
 }

int j=0;
for(int value=0;value<capacity;value++){
for(int reps=aux[value];reps>=1;reps--){
list[j]=value;
++j;
}
++g_contador;
}
free(aux);
}

6. Ejecución (1p)