5 Révisions

Auteur SHA1 Message Date
  dylan.cedres 7eb6233c87 Merge branch 'sortingFinal' of https://git.ccom.uprrp.edu/CCOM4030/AnCyDyJa into sortingFinal il y a 2 ans
  Jantony Velazquez Gauthier 34af7910c3 Add shellsort il y a 2 ans
  dylan.cedres 3856a55a76 Added Heapsort algorithm il y a 2 ans
  AngelRomero5 955a91ca74 Added merge algorithm il y a 2 ans
  AngelRomero5 2aea5dde9f Added Mergesort algorithm il y a 2 ans
1 fichiers modifiés avec 30 ajouts et 98 suppressions
  1. 30
    98
      sorting.py

+ 30
- 98
sorting.py Voir le fichier

@@ -8,7 +8,7 @@ Al final se imprimen los promedios de cada algortimo
8 8
 """
9 9
 from random import randint
10 10
 import time
11
-from heapq import heapify, heappush
11
+from copy import deepcopy
12 12
 
13 13
 def mergeSort(lista):
14 14
 	#definan el algoritmo de ordenamiento mergesort
@@ -16,115 +16,47 @@ def mergeSort(lista):
16 16
 
17 17
 def heapSort(lista):
18 18
 	#definan el algoritmo de ordenamiento heapsort
19
-	# Dylan A. Cedres Rivera
20
-
21
-	"""
22
-	Heapsort se conoce por ser un algoritmo de ordenamiento con las caracteristicas de un arbol binario, 
23
-		en donde cada nodo puede tener un maximo de hasta dos hijos, cumpliendo con las restricciones
24
-		de que el primer nodo debe ser el "nodo padre" (primer elemento en la lista, no puede ser hijo de otro nodo) y
25
-		las "hojas" del arbol binario deben ser solo "nodos hijos" (ultimos elementos de la lista, no pueden ser padres de otros nodos).
26
-	
27
-	El orden del heapsort puede ser MinHeap (menor a mayor), 
28
-		en donde el nodo padre del arbol binario es el elemento mas pequeno de la lista, 
29
-		o puede ser MaxHeap (mayor a menor), en donde el nodo padre es el elemento mas grande de la lista.
30
-	"""
31
-
32
-	# Nuevo heap para insertar los elementos de lista creada con numeros aleatorios
33
-	myHeap = []
34
-	heapify(myHeap)
35
-
36
-	# Se copian los elementos de lista al heap y se ordenan de menor a mayor los elementos con cada push.
37
-	# Todos los elementos se les asigna un signo contrario al que tienen, para poder crear un MaxHeap, de manera
38
-	# 	que los numeros mas grandes se convierten en los mas pequenos.
39
-	# Si se quiere hacer un MinHeap, la instruccion de multiplicar por -1 no es neceseria 
40
-	for element in lista:
41
-		heappush(myHeap, -1 * element)
42
-
43
-	# print("lista antes de 'heapificar'", lista)
44
-
45
-
46
-	# Este loop se utiliza para crear un MaxHeap, de manera que le devuelve el signo original que tenian los 
47
-	#	elementos antes de que se anadieran al heap.
48
-	# Esto significa que los elementos mas pequenos, se convierten en los mas grandes, dejando la forma de un MaxHeap,
49
-	#	con el numero mas grande quedando como el nodo padre del arbol binario.
50
-	# Si se quiere hacer un MinHeap, este loop no se necesita. 
51
-	for i in range(len(myHeap)):
52
-		myHeap[i] = myHeap[i] * -1
53
-
54
-	# print("lista 'heapificada'", myHeap)
55
-	
56
-	# Copia los elementos del heap ordenado de vuelta a la lista inicialmente generada y la devuelve
57
-	lista = myHeap
58 19
 	return lista
59 20
 
60 21
 def quickSort(lista):
61 22
 	#definan el algoritmo de ordenamiento quicksort
62 23
 	return lista
63 24
 
64
-# inplace
65
-# complexity: O(N^2)
66
-def shellSort(lst):
67
-    # initial gap
68
-    gap = len(lst)
69
-
70
-    while 0 < gap:
71
-        # sort every sublist with given gap
72
-        for start in range(gap):
73
-            f = range(start, len(lst), gap)
74
-            s = range(start + gap, len(lst), gap)
75
-
76
-            # bubble sort on sublist
77
-            swapped = True
78
-            while swapped:
79
-                swapped = False
80
-
81
-                # iterate through every adjacent pair in sublist
82
-                for c, n in zip(f, s):
83
-                    if lst[n] < lst[c]:
84
-                        lst[c], lst[n] = lst[n], lst[c]
85
-                        swapped = True
86
-
87
-        # reduce gap towards 0
88
-        gap = gap // 2
89
-
90
-    return lst
25
+def shellSort(lista):
26
+	#definan el algoritmo de ordenamiento shellsort
27
+	return lista
91 28
 
29
+# timeCode function/thunk -> (duration, return value)
30
+# measures the time it takes for a function/thunk to return
31
+def timeCode(fn):
32
+	t1 = time.perf_counter()
33
+	res = fn()
34
+	duration = time.perf_counter() - t1
35
+	return (duration, res)
92 36
 
93
-maxValor=1000 	#define el valor maximo de los elementos de la lista
94
-largoLista=1000 #define el largo de las listas a ordenar
95
-veces=100 		#define las veces que se va a hacer el ordenamiento 
37
+maxValor = 1000 	#define el valor maximo de los elementos de la lista
38
+largoLista = 1000 #define el largo de las listas a ordenar
39
+veces = 100 		#define las veces que se va a hacer el ordenamiento
96 40
 
97
-acumulaMerge=0 	#variable para acumular el tiempo de ejecucion del mergesort
98
-acumulaHeap=0 	#variable para acumular el tiempo de ejecucion del heapsort
99
-acumulaQuick=0 	#variable para acumular el tiempo de ejecucion del quicksort
100
-acumulaShell=0 	#variable para acumular el tiempo de ejecucion del shellsort
41
+acumulaMerge = 0 	#variable para acumular el tiempo de ejecucion del mergesort
42
+acumulaHeap = 0 	#variable para acumular el tiempo de ejecucion del heapsort
43
+acumulaQuick = 0 	#variable para acumular el tiempo de ejecucion del quicksort
44
+acumulaShell = 0 	#variable para acumular el tiempo de ejecucion del shellsort
101 45
 
102 46
 for i in range(veces):
103 47
 	mergelista = [randint(0,maxValor) for r in range(largoLista)] #creamos una lista con valores al azar
104
-	heaplista=list(mergelista)
105
-	quicklista=list(mergelista)
106
-	searchlista=list(mergelista)
48
+	heaplista = deepcopy(mergelista)
49
+	quicklista = deepcopy(mergelista)
50
+	searchlista = deepcopy(mergelista)
107 51
 
108
-	t1 = time.clock() 				#seteamos el tiempo al empezar
109
-	mergeSort(mergelista) 				#ejecutamos el algoritmo mergeSort
110
-	acumulaMerge+=time.clock()-t1 	#acumulamos el tiempo de ejecucion
111
-	
112
-	t1 = time.clock()				#seteamos el tiempo al empezar
113
-	heapSort(heaplista)					#ejecutamos el algoritmo heapSort
114
-	acumulaHeap+=time.clock()-t1 	#acumulamos el tiempo de ejecucion
115
-	
116
-	t1 = time.clock()				#seteamos el tiempo al empezar
117
-	quickSort(quicklista)				#ejecutamos el algoritmo quickSort
118
-	acumulaQuick+=time.clock()-t1 	#acumulamos el tiempo de ejecucion
119
-	
120
-	t1 = time.clock()				#seteamos el tiempo al empezar
121
-	shellSort(searchlista)				#ejecutamos el algoritmo shellSort
122
-	acumulaShell+=time.clock()-t1 	#acumulamos el tiempo de ejecucion
52
+	acumulaMerge += timeCode(lambda: mergeSort(mergelista))[0]
53
+	acumulaHeap += timeCode(lambda: heapSort(heaplista))[0]
54
+	acumulaQuick += timeCode(lambda: quickSort(quicklista))[0]
55
+	acumulaShell += timeCode(lambda: shellSort(searchlista))[0]
123 56
 
124 57
 #imprimos los resultados
125
-print( "Promedio de tiempo de ejecucion de "+ str(veces) +" listas de largo " + str(largoLista) )
126
-# print( "MergeSort " + str(acumulaMerge/veces) + " segundos" )
127
-print( "HeapSort " + str(acumulaHeap/veces) + " segundos" )
128
-# print( "QuickSort " + str(acumulaQuick/veces) + " segundos" )
129
-# print( "ShellSort " + str(acumulaShell/veces) + " segundos" )
130
-
58
+print(f"Promedio de tiempo de ejecucion de {str(veces)} listas de largo {str(largoLista)}")
59
+print(f"MergeSort {str(acumulaMerge / veces)} segundos")
60
+print(f"HeapSort {str(acumulaHeap / veces)} segundos")
61
+print(f"QuickSort {str(acumulaQuick / veces)} segundos")
62
+print(f"ShellSort {str(acumulaShell / veces)} segundos")