sorting.py

@@ -8,56 +8,45 @@ Al final se imprimen los promedios de cada algortimo
 """
 from random import randint
 import time
-<<<<<<< HEAD
-from heapq import heapify, heappush
-=======
->>>>>>> parent of e630181 (Switch list() to deepcopy() for tests)
+from copy import deepcopy
+import sys
 
-def mergeSort(lista):
-	#definan el algoritmo de ordenamiento mergesort
-	return lista
+# This function was created to prevent program from stopping before recursion finished
+# Changes python's recursion limit
+class recursion_depth:
+    def __init__(self, limit):
+        self.limit = limit
+        self.default_limit = sys.getrecursionlimit()
 
-def heapSort(lista):
-	#definan el algoritmo de ordenamiento heapsort
-	# Dylan A. Cedres Rivera
+    def __enter__(self):
+        sys.setrecursionlimit(self.limit)
+
+    def __exit__(self, type, value, traceback):
+        sys.setrecursionlimit(self.default_limit)
 
-	"""
-	Heapsort se conoce por ser un algoritmo de ordenamiento con las caracteristicas de un arbol binario, 
-		en donde cada nodo puede tener un maximo de hasta dos hijos, cumpliendo con las restricciones
-		de que el primer nodo debe ser el "nodo padre" (primer elemento en la lista, no puede ser hijo de otro nodo) y
-		las "hojas" del arbol binario deben ser solo "nodos hijos" (ultimos elementos de la lista, no pueden ser padres de otros nodos).
+# Mergesort algorithm
+def mergeSort(lista): # Ángel G. Romero Rosario on 10082022
 	
-	El orden del heapsort puede ser MinHeap (menor a mayor), 
-		en donde el nodo padre del arbol binario es el elemento mas pequeno de la lista, 
-		o puede ser MaxHeap (mayor a menor), en donde el nodo padre es el elemento mas grande de la lista.
-	"""
-
-	# Nuevo heap para insertar los elementos de lista creada con numeros aleatorios
-	myHeap = []
-	heapify(myHeap)
-
-	# Se copian los elementos de lista al heap y se ordenan de menor a mayor los elementos con cada push.
-	# Todos los elementos se les asigna un signo contrario al que tienen, para poder crear un MaxHeap, de manera
-	# 	que los numeros mas grandes se convierten en los mas pequenos.
-	# Si se quiere hacer un MinHeap, la instruccion de multiplicar por -1 no es neceseria 
-	for element in lista:
-		heappush(myHeap, -1 * element)
-
-	# print("lista antes de 'heapificar'", lista)
-
-
-	# Este loop se utiliza para crear un MaxHeap, de manera que le devuelve el signo original que tenian los 
-	#	elementos antes de que se anadieran al heap.
-	# Esto significa que los elementos mas pequenos, se convierten en los mas grandes, dejando la forma de un MaxHeap,
-	#	con el numero mas grande quedando como el nodo padre del arbol binario.
-	# Si se quiere hacer un MinHeap, este loop no se necesita. 
-	for i in range(len(myHeap)):
-		myHeap[i] = myHeap[i] * -1
-
-	# print("lista 'heapificada'", myHeap)
+	def merge(l1, l2):
+		if len(l1) == 0:
+			return l2
+		elif len(l2) == 0:
+			return l1
+		elif l1[0] < l2[0]:
+			return l1[0:1] + merge(l1[1:],l2)       # If l1[0] < l2[0] save l1[0] first to the list and call the function again
+		else:
+			return l2[0:1] + merge(l1, l2[1:])		# If l2[0] < l1[0] save l2[0] first to the list and call the function again
 	
-	# Copia los elementos del heap ordenado de vuelta a la lista inicialmente generada y la devuelve
-	lista = myHeap
+	if len(lista) <= 1:								# If there are no more items, return lista
+		return lista
+
+	else:
+		mid = len(lista) // 2 						# Find the middle in lista and call function to merge lista
+		return merge(mergeSort(lista[:mid]), mergeSort(lista[mid:]))
+
+
+def heapSort(lista):
+	#definan el algoritmo de ordenamiento heapsort
 	return lista
 
 def quickSort(lista):
@@ -74,7 +63,6 @@ def quickSort(lista):
           				x = i
           				del lista[lista.index(i)]
           				lista.insert(lista.index(p), x)
-          				print(lista)
  
       			l = quickSort(lista[ :lista.index(p)])
       			m = quickSort(lista[lista.index(p) + 1:])
@@ -116,48 +104,39 @@ def shellSort(lst):
 
     return lst
 
+# timeCode function/thunk -> (duration, return value)
+# measures the time it takes for a function/thunk to return
+def timeCode(fn):
+	t1 = time.perf_counter()
+	res = fn()
+	duration = time.perf_counter() - t1
+	return (duration, res)
 
-maxValor=1000 	#define el valor maximo de los elementos de la lista
-largoLista=1000 #define el largo de las listas a ordenar
-veces=100 		#define las veces que se va a hacer el ordenamiento 
+maxValor = 1000 	#define el valor maximo de los elementos de la lista
+largoLista = 1000   #define el largo de las listas a ordenar
+veces = 100 		#define las veces que se va a hacer el ordenamiento
 
-acumulaMerge=0 	#variable para acumular el tiempo de ejecucion del mergesort
-acumulaHeap=0 	#variable para acumular el tiempo de ejecucion del heapsort
-acumulaQuick=0 	#variable para acumular el tiempo de ejecucion del quicksort
-acumulaShell=0 	#variable para acumular el tiempo de ejecucion del shellsort
+acumulaMerge = 0 	#variable para acumular el tiempo de ejecucion del mergesort
+acumulaHeap = 0 	#variable para acumular el tiempo de ejecucion del heapsort
+acumulaQuick = 0 	#variable para acumular el tiempo de ejecucion del quicksort
+acumulaShell = 0 	#variable para acumular el tiempo de ejecucion del shellsort
 
 for i in range(veces):
 	mergelista = [randint(0,maxValor) for r in range(largoLista)] #creamos una lista con valores al azar
-<<<<<<< HEAD
-	heaplista=list(mergelista)
-	quicklista=list(mergelista)
-	searchlista=list(mergelista)
-=======
-	heaplista = list(mergelista)
-	quicklista = list(mergelista)
-	searchlista = list(mergelista)
->>>>>>> parent of e630181 (Switch list() to deepcopy() for tests)
-
-	t1 = time.clock() 				#seteamos el tiempo al empezar
-	mergeSort(mergelista) 				#ejecutamos el algoritmo mergeSort
-	acumulaMerge+=time.clock()-t1 	#acumulamos el tiempo de ejecucion
-	
-	t1 = time.clock()				#seteamos el tiempo al empezar
-	heapSort(heaplista)					#ejecutamos el algoritmo heapSort
-	acumulaHeap+=time.clock()-t1 	#acumulamos el tiempo de ejecucion
-	
-	t1 = time.clock()				#seteamos el tiempo al empezar
-	quickSort(quicklista)				#ejecutamos el algoritmo quickSort
-	acumulaQuick+=time.clock()-t1 	#acumulamos el tiempo de ejecucion
-	
-	t1 = time.clock()				#seteamos el tiempo al empezar
-	shellSort(searchlista)				#ejecutamos el algoritmo shellSort
-	acumulaShell+=time.clock()-t1 	#acumulamos el tiempo de ejecucion
+	heaplista = deepcopy(mergelista)
+	quicklista = deepcopy(mergelista)
+	searchlista = deepcopy(mergelista)
 
-#imprimos los resultados
-print( "Promedio de tiempo de ejecucion de "+ str(veces) +" listas de largo " + str(largoLista) )
-# print( "MergeSort " + str(acumulaMerge/veces) + " segundos" )
-print( "HeapSort " + str(acumulaHeap/veces) + " segundos" )
-# print( "QuickSort " + str(acumulaQuick/veces) + " segundos" )
-# print( "ShellSort " + str(acumulaShell/veces) + " segundos" )
+	with recursion_depth(1500): # This function excedes python's recursion limit
+		acumulaMerge += timeCode(lambda: mergeSort(mergelista))[0]
+
+	acumulaHeap += timeCode(lambda: heapSort(heaplista))[0]
+	acumulaQuick += timeCode(lambda: quickSort(quicklista))[0]
+	acumulaShell += timeCode(lambda: shellSort(searchlista))[0]
 
+#imprimos los resultados
+print(f"Promedio de tiempo de ejecucion de {str(veces)} listas de largo {str(largoLista)}")
+print(f"MergeSort {str(acumulaMerge / veces)} segundos")
+print(f"HeapSort {str(acumulaHeap / veces)} segundos")
+print(f"QuickSort {str(acumulaQuick / veces)} segundos")
+print(f"ShellSort {str(acumulaShell / veces)} segundos")