sorting.py

 """
 from random import randint
 import time
+import utils.qsortUtils as qsortUtils
 
 def mergeSort(lista):
 	#definan el algoritmo de ordenamiento mergesort
 	return lista
 
 def quickSort(lista):
-	#definan el algoritmo de ordenamiento quicksort
-	return lista
+	 # Se aplica quicksort a la lista desde el primer elemento hasta el último
+	return qsortUtils.qSort(lista, 0, len(lista) - 1)
 
 def shellSort(lista):
 	#definan el algoritmo de ordenamiento 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):
 	quicklista=list(mergelista)
 	searchlista=list(mergelista)
 
-	t1 = time.clock() 				#seteamos el tiempo al empezar
+	t1 = time.perf_counter() 				#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
+	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.clock()-t1 	#acumulamos el tiempo de ejecucion
-
-	t1 = time.clock()				#seteamos el tiempo al empezar
+	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.clock()-t1 	#acumulamos el tiempo de ejecucion
-
-	t1 = time.clock()				#seteamos el tiempo al empezar
+	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.clock()-t1 	#acumulamos el tiempo de ejecucion
+	acumulaShell+=time.perf_counter()-t1 	#acumulamos el tiempo de ejecucion
 
 #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"
+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")

test_sortAlgo.py

+from email import utils
+
+
+from utils import qsortUtils
+from random import randint
+
+enteros = [0,7,3,1,4,5,2]
+negativos = [8,-1,3,2,-4,9]
+aleatoria =[randint(-49,50) for r in range(10)]
+
+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())
+

utils/qsortUtils.py

+# 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): 
+
+  x = lista[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
+      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]
+
+  lista[i+1], lista[r] = lista[r], lista[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):
+
+  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
+