Arreglos de indentacion y debug de quicksort. Modificacion al modulo de prueba.

sorting.py

@@ -15,7 +15,8 @@ def mergeSort(lista):
 	# If the size of the list is greater than 1 then it enters here
 	if len(lista) > 1:
 		# Gets the half of the list
-		Midd = len(lista) / 2
+		Midd = len(lista) // 2
+
 		# Takes only the elements that are in the left of the list
 		Left = lista[Midd:]
 		# If the size of left still is not 1 then
@@ -30,35 +31,35 @@ def mergeSort(lista):
 			mergeSort(Right)
 
 		# Variables define for while and getting space in the list
-        i = j = k = 0
+		i = j = k = 0
 
 		# While i and j are less than the comparation it enters here
-        while i < len(Left) and j < len(Right):
+		while i < len(Left) and j < len(Right):
 			# If the compared number in i is less than j it enters here
-            if Left[i] < Right[j]:
+			if Left[i] < Right[j]:
 				# The less variable is stored in the list again in order
-                lista[k] = Left[i]
-                i += 1 # Increments i
+				lista[k] = Left[i]
+				i += 1 # Increments i
 			# If the compared number in i is greater than j it enters here
-            else:
+			else:
 				# The less variable is stored in the list again in order
-                lista[k] = Right[j]
-                j += 1 # Increments j
-            k += 1 # Increments k
+				lista[k] = Right[j]
+				j += 1 # Increments j
+			k += 1 # Increments k
 
 		# If there are elements remaining in Left the they are put here
-        while i < len(Left):
+		while i < len(Left):
 			# The variable that was remaining is put here
-            lista[k] = Left[i]
-            i += 1 # Increments i
-            k += 1 # Increments k
+			lista[k] = Left[i]
+			i += 1 # Increments i
+			k += 1 # Increments k
 
 		# If there are elements remaining in Right the they are put here
-        while j < len(Right):
+		while j < len(Right):
 			# The variable that was remaining is put here
-            lista[k] = Right[j]
-            j += 1 # Increments j
-            k += 1 # Increments k
+			lista[k] = Right[j]
+			j += 1 # Increments j
+			k += 1 # Increments k
 
 	return lista
 	# Code was base and taken from GeeksforGeeks
@@ -68,13 +69,15 @@ def heapSort(lista):
 	return lista
 
 def quickSort(lista):
-	 # Se aplica quicksort a la lista desde el primer elemento hasta el último
-	return qsortUtils.qSort(lista, 0, len(lista) - 1)
+	# Se aplica quicksort a la lista desde el primer elemento hasta el último
+	qsortUtils.qSort(lista, 0, len(lista) - 1)
+	
+	return lista
 
 def shellSort(lista):
 	#definan el algoritmo de ordenamiento shellsort
 	Size = len(lista) # Contains the complete size of the list
-	Diff = Size/2 # Contains the number of half of the list
+	Diff = Size//2 # Contains the number of half of the list
 
 	# Does a insertion sort by ordering in base of the Diff.
 	while Diff > 0:
@@ -92,47 +95,51 @@ def shellSort(lista):
 			# Puts the Tmp variable in is correct location
 			lista[j] = Tmp
 		# Reduces again the list
-		Diff /= 2
+		Diff //= 2
 
 	return lista
 	# Code was taken from GeeksforGeeks
 
-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=list(mergelista)
-	quicklista=list(mergelista)
-	searchlista=list(mergelista)
-
-	t1 = time.perf_counter() 				#seteamos el tiempo al empezar
-	mergeSort(mergelista) 				#ejecutamos el algoritmo mergeSort
-	acumulaMerge+=time.perf_counter()-t1 	#acumulamos el tiempo de ejecucion
-	
-	t1 = time.perf_counter()			#seteamos el tiempo al empezar
-	heapSort(heaplista)					#ejecutamos el algoritmo heapSort
-	acumulaHeap+=time.perf_counter()-t1 	#acumulamos el tiempo de ejecucion
-	
-	t1 = time.perf_counter()				#seteamos el tiempo al empezar
-	quickSort(quicklista)				#ejecutamos el algoritmo quickSort
-	acumulaQuick+=time.perf_counter()-t1 	#acumulamos el tiempo de ejecucion
-	
-	t1 = time.perf_counter()				#seteamos el tiempo al empezar
-	shellSort(searchlista)				#ejecutamos el algoritmo shellSort
-	acumulaShell+=time.perf_counter()-t1 	#acumulamos el tiempo de ejecucion
-
-#imprimos los resultados
-print (f"Promedio de tiempo de ejecucion de {veces} listas de largo {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")
+def main():
+	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=list(mergelista)
+		quicklista=list(mergelista)
+		searchlista=list(mergelista)
+
+		t1 = time.perf_counter() 				#seteamos el tiempo al empezar
+		mergeSort(mergelista) 				#ejecutamos el algoritmo mergeSort
+		acumulaMerge+=time.perf_counter()-t1 	#acumulamos el tiempo de ejecucion
+		
+		t1 = time.perf_counter()			#seteamos el tiempo al empezar
+		heapSort(heaplista)					#ejecutamos el algoritmo heapSort
+		acumulaHeap+=time.perf_counter()-t1 	#acumulamos el tiempo de ejecucion
+		
+		t1 = time.perf_counter()				#seteamos el tiempo al empezar
+		quickSort(quicklista)				#ejecutamos el algoritmo quickSort
+		acumulaQuick+=time.perf_counter()-t1 	#acumulamos el tiempo de ejecucion
+		
+		t1 = time.perf_counter()				#seteamos el tiempo al empezar
+		shellSort(searchlista)				#ejecutamos el algoritmo shellSort
+		acumulaShell+=time.perf_counter()-t1 	#acumulamos el tiempo de ejecucion
+
+	#imprimos los resultados
+	print (f"Promedio de tiempo de ejecucion de {veces} listas de largo {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")
+
+if __name__ == "__main__":
+	main()

test_sortAlgo.py

@@ -1,14 +1,69 @@
-from email import utils
+import sorting
+from random import randint
 
+DEBUG_OUTPUT = True
 
-from utils import qsortUtils
-from random import randint
+def test_mergeSort(pruebas):
+    FAIL = False
+
+    print("\nProbando MergeSort")
+
+    for nombre, lista in pruebas.items():
+        if sorting.mergeSort(lista) == sorted(lista):
+            print(f"{nombre}: " + "Pass")
+        else:
+            print(f"{nombre}: " + "Fail")
+            FAIL = True
+
+    if FAIL == True and DEBUG_OUTPUT == True:
+        print("\n Test FAIL OUTPUT for MergeSort")
+        for nombre, lista in pruebas.items():
+            print(f"{nombre}: Obtained -> {sorting.mergeSort(lista)} | Expected -> {sorted(lista)}")    
+
+def test_quickSort(pruebas):
+    FAIL = False
+
+    print("\nProbando QuickSort")
+
+    for nombre, lista in pruebas.items():
+        if sorting.quickSort(lista) == sorted(lista):
+            print(f"{nombre}: " + "Pass")
+        else:
+            print(f"{nombre}: " + "Fail")
+            FAIL = True
+
+    if FAIL == True and DEBUG_OUTPUT == True:
+        print("\n Test FAIL OUTPUT for QuickSort")
+        for nombre, lista in pruebas.items():
+            print(f"{nombre}: Obtained -> {sorting.quickSort(lista)} | Expected -> {sorted(lista)}")   
+
+def test_shellSort(pruebas):
+    FAIL = False
+
+    print("\nProbando ShellSort")
+
+    for nombre, lista in pruebas.items():
+        if sorting.shellSort(lista) == sorted(lista):
+            print(f"{nombre}: " + "Pass")
+        else:
+            print(f"{nombre}: " + "Fail")
+            FAIL = True
 
-enteros = [0,7,3,1,4,5,2]
-negativos = [8,-1,3,2,-4,9]
-aleatoria =[randint(-49,50) for r in range(10)]
+    if FAIL == True and DEBUG_OUTPUT == True:
+        print("\n Test FAIL OUTPUT for ShellSort")
+        for nombre, lista in pruebas.items():
+            print(f"{nombre}: Obtained -> {sorting.shellSort(lista)} | Expected -> {sorted(lista)}")   
 
-print(qsortUtils.qSort(enteros,0,len(enteros)-1) == enteros.sort())
-print(qsortUtils.qSort(negativos,0,len(negativos)-1) == negativos.sort())
-print(qsortUtils.qSort(aleatoria,0,len(aleatoria)-1) == aleatoria.sort())
+def main():
+    PRUEBAS = {"Enteros":[0,7,3,1,4,5,2],
+               "Negativos":[8,-1,3,2,-4,9],
+               "Aleatorios":[randint(-49,50) for r in range(10)],
+               "Vacia":[],
+               "Ordenada":[1,2,3,4,5,6,7]}
+    
+    test_mergeSort(PRUEBAS)
+    test_quickSort(PRUEBAS)
+    test_shellSort(PRUEBAS)
 
+if __name__ == "__main__":
+    main()

utils/qsortUtils.py

@@ -1,24 +1,25 @@
 # Función partition: Selecciona el pivote y divide la lista en dos conjuntos: Elementos menores o iguales al pivote y elementos mayores al pivote
-def partition(lista, p, r): 
+def partition(A, p, r): 
 
-  x = lista[r] # Selección del último elemento en la lista como el pivote
+  x = A[r] # Selección del último elemento en la lista como el pivote
   i = p - 1 # El conjunto de elementos menores o iguales al pivote está inicialmente vacío
 
   for j in range (p, r):
 
-    if lista[j] <= x: # Comparación de elemento en la lista con el pivote
+    if A[j] <= x: # Comparación de elemento en la lista con el pivote
       i += 1 # Hacer espacio para el elemento A[j], se coloca un espacio luego del último elemento del conjunto de elementos menores o iguales al pivote.
-      lista[j], lista[i] = lista[i], lista[j] #Swap A[j] con A[i]
+      A[j], A[i] = A[i], A[j] #Swap A[j] con A[i]
 
-  lista[i+1], lista[r] = lista[r], lista[i+1] # Colocar el pivote como último elemento del conjunto de menores o iguales
+  A[i+1], A[r] = A[r], A[i+1] # Colocar el pivote como último elemento del conjunto de menores o iguales
 
   return i + 1 # Devuelve el índice del pivote actual
 
 # Función qSort: Aplica el algoritmo de Quicksort a una lista
-def qSort(lista, p, r):
+def qSort(A, p, r):
 
   if p < r: # Caso Base: Se llegó a un elemento individual. La lista es un solo elemento
-    q = partition(lista, p, r) # Divide/Combine: Particiona la lista y se obtiene el índice del pivote
-    qSort(lista, p, q - 1) # Conquer: Se aplica qSort al conjunto de elementos menores o iguales al pivote actual
-    qSort(lista, q + 1, r) # Conquer: Se aplica qSort al conjunto de elementos mayores al pivote actual
+    q = partition(A, p, r) # Divide/Combine: Particiona la lista y se obtiene el índice del pivote
+    qSort(A, p, q - 1) # Conquer: Se aplica qSort al conjunto de elementos menores o iguales al pivote actual
+    qSort(A, q + 1, r) # Conquer: Se aplica qSort al conjunto de elementos mayores al pivote actual
+