|
|
@@ -6,6 +6,7 @@ La variable largoLista define el largo de las listas a ordenar
|
|
6
|
6
|
La variable veces define las veces que se va a hacer el ordenamiento
|
|
7
|
7
|
Al final se imprimen los promedios de cada algortimo
|
|
8
|
8
|
"""
|
|
|
9
|
+
|
|
9
|
10
|
from random import randint
|
|
10
|
11
|
import time
|
|
11
|
12
|
|
|
|
@@ -16,6 +17,16 @@ def mergeSort(lista):
|
|
16
|
17
|
def heapSort(lista):
|
|
17
|
18
|
#trabajado por Andrel Fuentes
|
|
18
|
19
|
#definan el algoritmo de ordenamiento heapsort
|
|
|
20
|
+
|
|
|
21
|
+ #crear el "max heap"
|
|
|
22
|
+ for i in range(largoLista // 2, -1, -1):
|
|
|
23
|
+ heapify(lista, largoLista, i)
|
|
|
24
|
+
|
|
|
25
|
+ for i in range(largoLista - 1, 0, -1):
|
|
|
26
|
+ lista[i], lista[0] = lista[0], lista[i]
|
|
|
27
|
+
|
|
|
28
|
+ heapify(lista, i, 0)
|
|
|
29
|
+
|
|
19
|
30
|
return lista
|
|
20
|
31
|
|
|
21
|
32
|
def quickSort(lista):
|
|
|
@@ -26,6 +37,34 @@ def shellSort(lista):
|
|
26
|
37
|
#definan el algoritmo de ordenamiento shellsort
|
|
27
|
38
|
return lista
|
|
28
|
39
|
|
|
|
40
|
+#######################################################################################
|
|
|
41
|
+
|
|
|
42
|
+def heapify(lista, largo, raiz):
|
|
|
43
|
+ #trabajado por Andrel Fuentes
|
|
|
44
|
+ #encontrar cual el valor mayor entre de los hijos y raiz
|
|
|
45
|
+ #define las posiciones de los hijos
|
|
|
46
|
+ largest_value = raiz
|
|
|
47
|
+ left_child = raiz * 2 + 1
|
|
|
48
|
+ right_child = raiz * 2 + 2
|
|
|
49
|
+
|
|
|
50
|
+ #se verifica si el hijo izquierdo es mayor, actualizar variable de mayor
|
|
|
51
|
+ #si fuera necesario
|
|
|
52
|
+ if left_child < largoLista and lista[left_child] > lista[raiz]:
|
|
|
53
|
+ largest_value = left_child
|
|
|
54
|
+
|
|
|
55
|
+ #se verifica si el hijo derecho es mayor, actualizar variable de mayor
|
|
|
56
|
+ #si fuera necesario
|
|
|
57
|
+ if right_child < largoLista and lista[right_child] > lista[largest_value]:
|
|
|
58
|
+ largest_value = right_child
|
|
|
59
|
+
|
|
|
60
|
+ #se verifica si la posicion inicial sigue siendo la misma/mayor, swap si necesario
|
|
|
61
|
+ #y continuar con heapify
|
|
|
62
|
+ if largest_value != raiz:
|
|
|
63
|
+ lista[raiz], lista[largest_value] = lista[largest_value], lista[raiz]
|
|
|
64
|
+ heapify(lista, largo, largest_value)
|
|
|
65
|
+
|
|
|
66
|
+#######################################################################################
|
|
|
67
|
+
|
|
29
|
68
|
maxValor=1000 #define el valor maximo de los elementos de la lista
|
|
30
|
69
|
largoLista=1000 #define el largo de las listas a ordenar
|
|
31
|
70
|
veces=100 #define las veces que se va a hacer el ordenamiento
|
|
|
@@ -41,26 +80,26 @@ for i in range(veces):
|
|
41
|
80
|
quicklista=list(mergelista)
|
|
42
|
81
|
searchlista=list(mergelista)
|
|
43
|
82
|
|
|
44
|
|
- t1 = time.clock() #seteamos el tiempo al empezar
|
|
|
83
|
+ t1 = time.process_time() #seteamos el tiempo al empezar
|
|
45
|
84
|
mergeSort(mergelista) #ejecutamos el algoritmo mergeSort
|
|
46
|
|
- acumulaMerge+=time.clock()-t1 #acumulamos el tiempo de ejecucion
|
|
47
|
|
-
|
|
48
|
|
- t1 = time.clock() #seteamos el tiempo al empezar
|
|
|
85
|
+ acumulaMerge+=time.process_time()-t1 #acumulamos el tiempo de ejecucion
|
|
|
86
|
+
|
|
|
87
|
+ t1 = time.process_time() #seteamos el tiempo al empezar
|
|
49
|
88
|
heapSort(heaplista) #ejecutamos el algoritmo heapSort
|
|
50
|
|
- acumulaHeap+=time.clock()-t1 #acumulamos el tiempo de ejecucion
|
|
51
|
|
-
|
|
52
|
|
- t1 = time.clock() #seteamos el tiempo al empezar
|
|
|
89
|
+ acumulaHeap+=time.process_time()-t1 #acumulamos el tiempo de ejecucion
|
|
|
90
|
+
|
|
|
91
|
+ t1 = time.process_time() #seteamos el tiempo al empezar
|
|
53
|
92
|
quickSort(quicklista) #ejecutamos el algoritmo quickSort
|
|
54
|
|
- acumulaQuick+=time.clock()-t1 #acumulamos el tiempo de ejecucion
|
|
55
|
|
-
|
|
56
|
|
- t1 = time.clock() #seteamos el tiempo al empezar
|
|
|
93
|
+ acumulaQuick+=time.process_time()-t1 #acumulamos el tiempo de ejecucion
|
|
|
94
|
+
|
|
|
95
|
+ t1 = time.process_time() #seteamos el tiempo al empezar
|
|
57
|
96
|
shellSort(searchlista) #ejecutamos el algoritmo shellSort
|
|
58
|
|
- acumulaShell+=time.clock()-t1 #acumulamos el tiempo de ejecucion
|
|
|
97
|
+ acumulaShell+=time.process_time()-t1 #acumulamos el tiempo de ejecucion
|
|
59
|
98
|
|
|
60
|
99
|
#imprimos los resultados
|
|
61
|
|
-print "Promedio de tiempo de ejecucion de "+ str(veces) +" listas de largo " + str(largoLista)
|
|
62
|
|
-print "MergeSort " + str(acumulaMerge/veces) + " segundos"
|
|
63
|
|
-print "HeapSort " + str(acumulaHeap/veces) + " segundos"
|
|
64
|
|
-print "QuickSort " + str(acumulaQuick/veces) + " segundos"
|
|
65
|
|
-print "ShellSort " + str(acumulaShell/veces) + " segundos"
|
|
|
100
|
+print ("Promedio de tiempo de ejecucion de "+ str(veces) +" listas de largo " + str(largoLista))
|
|
|
101
|
+print ("MergeSort " + str(acumulaMerge/veces) + " segundos")
|
|
|
102
|
+print ("HeapSort " + str(acumulaHeap/veces) + " segundos")
|
|
|
103
|
+print ("QuickSort " + str(acumulaQuick/veces) + " segundos")
|
|
|
104
|
+print ("ShellSort " + str(acumulaShell/veces) + " segundos")
|
|
66
|
105
|
|
