HOJA DE TRABAJO PARA LA

PRÁCTICA 2: Algoritmos de
ordenamiento II

QuickSort

Comparaciones [0.5p]
Indica el valor teórico correspondiente a O( n log n ) cuando n=5000.
R:____61438.5619____.

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

cuando n=5000.
R: ___36822_____.

¿El número de comparaciones que obtuviste a qué se parece más, y porqué? O( n log n ) o
a O( n2 ) (utiliza las líneas que sean necesarias):

R: El número que obtuve se parece mas a O(n log n), ya que si fuera O( n2) el valor se
tendría que parecer a veinticinco millones, lo cual es muy alejado.

Función mediana_de_3() [2.5p]

int mediana_de_3(int primero,int mid,int ultimo){
if( primero > mid && primero < ultimo ){
return primero;
}
else if( mid > primero && mid < ultimo ){
return mid;
}else
return ultimo;
}
Función quick_sort() utilizando la mediana_de_3() [1p]
void quick_sort(int list[],int first, int last){
int x0=first;
int x1=last;
int mid=(sizeof(list)/sizeof(int))/2;
int piv=mediana_de_3(list[0],list[(x0+x1)/2],list[x1]);;

while(x0<=x1){
g_comparaciones++;
while(list[x0]<piv){
x0++;
}
g_comparaciones++;
while(list[x1]>piv){
x1--;
}
if(x0<=x1){
swap(&list[x0],&list[x1]);
x0++;
x1--;
}
}
if(first<x1){
quick_sort(list,first,x1);
}
if(x0<last){
quick_sort(list,x0,last);
}
}

HeapSort

Comparaciones [0.5p]
Indica el valor teórico correspondiente a O( n log n ) cuando n=5000.
R:___61438.5619_____.
Indica el número de comparaciones que obtuviste en alguna corrida de tu programa
cuando n=5000.
R: ___59544_____.
¿El número de comparaciones que obtuviste a qué se parece más, y porqué? O( n log n ) o
a O( n2 ) (utiliza las líneas que sean necesarias):

R: Nuevamente el valor obtenido se aproxima más a una O(n log n), ya que de ser O( n2)
tendría que aproximarse a veinticinco millones, esto deja muy claro que se trata de una
eficiencia n log n.

Función build_min_heap() [2p]

void build_min_heap(int list[],int tam){
for(int r=(tam/2);r>=1;r--){
heapify(list,tam,r-1);
}
}

Función heapify_desc() [1p]

void heapify_des(int list[],int tam,int r){
int left=2*r+1;
int right=2*r+2;
int largest = r;
g_comparaciones++;
if(left<tam and list[left]<list[r]){
largest=left;
}
g_comparaciones++;
if(right<tam and list[right]<list[largest]){
largest=right;
}
if(largest !=r){
swap(&list[r],&list[largest]);
heapify_des(list,tam,largest);
}
}

Función heap_sort() [1p]

void heap_sort(int list[],int tam){
build_max_heap(list,tam);
 for(int i=tam;i>=1;i--){
swap(&list[0],&list[i-1]);
heapify(list,i-1,0);
}
}

Ejecución [0.5p]

Comparación de algoritmos [1p]

Llena la siguiente tabla. Utiliza un arreglo de 5000 elementos aleatorios.

Algoritmo Comparaciones

QuickSort/punto medio 37400

QuickSort/mediana de 3 36952

HeapSort 59591