Make sortingFinal

sorting.py

@@ -8,7 +8,10 @@ Al final se imprimen los promedios de cada algortimo
 """
 from random import randint
 import time
-from copy import deepcopy
+<<<<<<< HEAD
+from heapq import heapify, heappush
+=======
+>>>>>>> parent of e630181 (Switch list() to deepcopy() for tests)
 
 def mergeSort(lista):
 	#definan el algoritmo de ordenamiento mergesort
@@ -16,47 +19,145 @@ def mergeSort(lista):
 
 def heapSort(lista):
 	#definan el algoritmo de ordenamiento heapsort
+	# Dylan A. Cedres Rivera
+
+	"""
+	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).
+	
+	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)
+	
+	# Copia los elementos del heap ordenado de vuelta a la lista inicialmente generada y la devuelve
+	lista = myHeap
 	return lista
 
 def quickSort(lista):
 	#definan el algoritmo de ordenamiento quicksort
-	return lista
+	if(len(lista) != 0):
+    		if(len(lista) == 1):
+      			return lista
 
-def shellSort(lista):
-	#definan el algoritmo de ordenamiento shellsort
-	return lista
+    		else:
+      			p = lista[0]
+
+      			for i in lista[1:]:
+        			if(p > i):
+          				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:])
 
-# 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)
+      			if(m != None and l != None):
+        			return l + lista[lista.index(p):lista.index(p) + 1] + m
 
-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
+      			elif(m == None):
+        			return l + lista[lista.index(p):lista.index(p) + 1]
 
-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
+      			elif(l == None):
+        			return lista[lista.index(p):lista.index(p) + 1] + m
+
+# inplace
+# complexity: O(N^2)
+def shellSort(lst):
+    # initial gap
+    gap = len(lst)
+
+    while 0 < gap:
+        # sort every sublist with given gap
+        for start in range(gap):
+            f = range(start, len(lst), gap)
+            s = range(start + gap, len(lst), gap)
+
+            # bubble sort on sublist
+            swapped = True
+            while swapped:
+                swapped = False
+
+                # iterate through every adjacent pair in sublist
+                for c, n in zip(f, s):
+                    if lst[n] < lst[c]:
+                        lst[c], lst[n] = lst[n], lst[c]
+                        swapped = True
+
+        # reduce gap towards 0
+        gap = gap // 2
+
+    return lst
+
+
+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
 
 for i in range(veces):
 	mergelista = [randint(0,maxValor) for r in range(largoLista)] #creamos una lista con valores al azar
-	heaplista = deepcopy(mergelista)
-	quicklista = deepcopy(mergelista)
-	searchlista = deepcopy(mergelista)
+<<<<<<< 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)
 
-	acumulaMerge += timeCode(lambda: mergeSort(mergelista))[0]
-	acumulaHeap += timeCode(lambda: heapSort(heaplista))[0]
-	acumulaQuick += timeCode(lambda: quickSort(quicklista))[0]
-	acumulaShell += timeCode(lambda: shellSort(searchlista))[0]
+	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
 
 #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")
+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" )
+