Added quicksort algorithm

sorting.py

@@ -10,8 +10,10 @@ Al final se imprimen los promedios de cada algortimo
 from random import randint
 import time
 
-#Defini esta funcion de swap para facilitarme este paso del sort.
-#Lo pueden usar si quieren.
+# Defini esta funcion de swap para facilitarme este paso del sort.
+# Lo pueden usar si quieren.
+
+
 def swap(lista, posicion1, posicion2):
     tmp = lista[posicion1]
     lista[posicion1] = lista[posicion2]
@@ -19,190 +21,215 @@ def swap(lista, posicion1, posicion2):
 
 
 def mergeSort(lista):
-	#definan el algoritmo de ordenamiento mergesort
-	if len(lista) > 1:
-		mid = len(lista)//2
-		left = lista[:mid]
-		right = lista[mid:]
-		mergeSort(left)
-		mergeSort(right)
-		
-		i = j = k = 0
-		
-		while i < len(left) and j < len(right):
-			if left[i] < right[j]:
-				lista[k] = left[i]
-				i += 1
-			else:
-				lista[k] = right[j]
-				j += 1
-			k += 1
-		while i < len(left):
-			lista[k] = left[i]
-			i += 1
-			k += 1
-		while j < len(right):
-			lista[k] = right[j]
-			j += 1
-			k += 1
-
-	return lista
+    # definan el algoritmo de ordenamiento mergesort
+    if len(lista) > 1:
+        mid = len(lista)//2
+        left = lista[:mid]
+        right = lista[mid:]
+        mergeSort(left)
+        mergeSort(right)
+
+        i = j = k = 0
+
+        while i < len(left) and j < len(right):
+            if left[i] < right[j]:
+                lista[k] = left[i]
+                i += 1
+            else:
+                lista[k] = right[j]
+                j += 1
+            k += 1
+        while i < len(left):
+            lista[k] = left[i]
+            i += 1
+            k += 1
+        while j < len(right):
+            lista[k] = right[j]
+            j += 1
+            k += 1
+
+    return lista
 
 
 # Tomada de: https://www.geeksforgeeks.org/heap-sort/
 # To heapify subtree rooted at index i.
-# n is size of heap 
+# n is size of heap
 def heapify(arr, n, i):
     largest = i  # Initialize largest as root
     l = 2 * i + 1     # left = 2*i + 1
     r = 2 * i + 2     # right = 2*i + 2
- 
+
     # See if left child of root exists and is
     # greater than root
     if l < n and arr[largest] < arr[l]:
         largest = l
- 
+
     # See if right child of root exists and is
     # greater than root
     if r < n and arr[largest] < arr[r]:
         largest = r
- 
+
     # Change root, if needed
     if largest != i:
         arr[i], arr[largest] = arr[largest], arr[i]  # swap
- 
+
         # Heapify the root.
         heapify(arr, n, largest)
 
 # Tomada de: https://www.geeksforgeeks.org/heap-sort/
-def heapSort(lista):
-	#definan el algoritmo de ordenamiento heapsort
-	n = len(lista)
- 
-    # Build a maxheap.
-	for i in range(n//2 - 1, -1, -1):
-		heapify(lista, n, i)
- 
-    # One by one extract elements
-	for i in range(n-1, 0, -1):
-		lista[i], lista[0] = lista[0], lista[i]  # swap
-		heapify(lista, i, 0)
- 
-	return lista
 
 
-def quickSort(lista):
-	#definan el algoritmo de ordenamiento quicksort
-	return lista
-
+def heapSort(lista):
+    # definan el algoritmo de ordenamiento heapsort
+    n = len(lista)
 
-def shellSort(lista):
-	#definan el algoritmo de ordenamiento shellsort
-        
-        #Variable para saber cuando el sort termina
-        termine = False
-        #Variable para el tamaño de la lista.
-        n = len(lista)
-        #Variable para la mitad del tamaño de la lista.
-        k = int(n/2)
-        #Variables para realizar las comparaciones de los elementos.
-        i = 0
-        j = k
-
-        #Ciclo donde se realiza el ShellSort.
-        while(termine == False):
-
-            #Comparacion de elementos para ver si se puede hacer un swap.
-            if(lista[i] > lista[j]):
-                
-                swap(lista, i, j)
-
-                #Variables para retener el valor original de x, y para continuar el sort.
-                tmp1 = i
-                tmp2 = j
-
-                #Ciclo para realizar swaps en elementos anteriores luego de encontrar un swap.
-                while True:
-
-                    #Verificacion para prevenir que se busquen elementos fuera de la lista.
-                    if((i-k) >= 0):
-                        i = i - k
-                        j = j -k
-                    else:
-                        i = tmp1
-                        j = tmp2
-                        break
-                    
-                    #Verificacion si se puede hacer otro swap.
-                    if(lista[i] > lista[j]):
-                        swap(lista, i , j)
-                    else:
-                        i = tmp1
-                        j = tmp2
-                        break
-
-                #Estos ajustes se utilizan para continuar verificando elementos
-                #mas adelantes en la lista.
-                i = i + 1
-                j = j + 1
+    # Build a maxheap.
+    for i in range(n//2 - 1, -1, -1):
+        heapify(lista, n, i)
 
-            else:
-                #Estos ajustes se utilizan para continuar verificando elementos
-                #mas adelantes en la lista.
-                i = i + 1
-                j = j + 1
+    # One by one extract elements
+    for i in range(n-1, 0, -1):
+        lista[i], lista[0] = lista[0], lista[i]  # swap
+        heapify(lista, i, 0)
 
+    return lista
 
-            #Verifica antes de salirse de la lista para poder comenzar otra vuelta con k/2.
-            if(j == n):
-                k = int(k/2)
-                i = 0 
-                j = k
 
-            #Identifica cuando el sort se supone que haya terminado.
-            if(k == 0):
-                termine = True
+def quickSort(lista):
+    # definan el algoritmo de ordenamiento quicksort
 
+    # If lista is empty or has only one element.
+    if len(lista) <= 1:
         return lista
 
+    # Else, set pivot to a random element of the list.
+    else:
+        pivot = lista[randint(0, len(lista)-1)]
+
+        # Create three list for the numbers lesser, equal and greater than the pivot.
+        lesser = []
+        equal = []
+        greater = []
+
+        # Iterate through the list and add the elements to the respective list.
+        for i in lista:
+            if i < pivot:
+                lesser.append(i)
+            elif i > pivot:
+                greater.append(i)
+            else:
+                equal.append(i)
+        # Recursively call quickSort on the two lists and concatenate them with the equal list.
+        return quickSort(lesser) + equal + quickSort(greater)
 
-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
+def shellSort(lista):
+    # definan el algoritmo de ordenamiento shellsort
+
+    # Variable para saber cuando el sort termina
+    termine = False
+    # Variable para el tamaño de la lista.
+    n = len(lista)
+    # Variable para la mitad del tamaño de la lista.
+    k = int(n/2)
+    # Variables para realizar las comparaciones de los elementos.
+    i = 0
+    j = k
+
+    # Ciclo donde se realiza el ShellSort.
+    while(termine == False):
+
+        # Comparacion de elementos para ver si se puede hacer un swap.
+        if(lista[i] > lista[j]):
+
+            swap(lista, i, j)
+
+            # Variables para retener el valor original de x, y para continuar el sort.
+            tmp1 = i
+            tmp2 = j
+
+            # Ciclo para realizar swaps en elementos anteriores luego de encontrar un swap.
+            while True:
+
+                # Verificacion para prevenir que se busquen elementos fuera de la lista.
+                if((i-k) >= 0):
+                    i = i - k
+                    j = j - k
+                else:
+                    i = tmp1
+                    j = tmp2
+                    break
+
+                # Verificacion si se puede hacer otro swap.
+                if(lista[i] > lista[j]):
+                    swap(lista, i, j)
+                else:
+                    i = tmp1
+                    j = tmp2
+                    break
+
+            # Estos ajustes se utilizan para continuar verificando elementos
+            # mas adelantes en la lista.
+            i = i + 1
+            j = j + 1
+
+        else:
+            # Estos ajustes se utilizan para continuar verificando elementos
+            # mas adelantes en la lista.
+            i = i + 1
+            j = j + 1
+
+        # Verifica antes de salirse de la lista para poder comenzar otra vuelta con k/2.
+        if(j == n):
+            k = int(k/2)
+            i = 0
+            j = k
+
+        # Identifica cuando el sort se supone que haya terminado.
+        if(k == 0):
+            termine = True
+
+    return lista
+
+
+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):
-	lista = [randint(0,maxValor) for r in range(largoLista)] #creamos una lista con valores al azar
-
-	listaMerge = lista[:]
-	listaHeap = lista[:]
-	listaQuick = lista[:]
-	listaShell = lista[:]
-	
-	t1 = time.process_time()				#seteamos el tiempo al empezar
-	mergeSort(listaMerge) 						#ejecutamos el algoritmo mergeSort
-	acumulaMerge+=time.process_time()-t1 	#acumulamos el tiempo de ejecucion
-	
-	t1 = time.process_time()				#seteamos el tiempo al empezar
-	heapSort(listaHeap)							#ejecutamos el algoritmo heapSort
-	acumulaHeap+=time.process_time()-t1 	#acumulamos el tiempo de ejecucion
-	
-	t1 = time.process_time()						#seteamos el tiempo al empezar
-	quickSort(listaQuick)						#ejecutamos el algoritmo quickSort
-	acumulaQuick+=time.process_time()-t1 	#acumulamos el tiempo de ejecucion
-	
-	t1 = time.process_time()				#seteamos el tiempo al empezar
-	shellSort(listaShell)						#ejecutamos el algoritmo shellSort
-	acumulaShell+=time.process_time()-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")
-
+    # creamos una lista con valores al azar
+    lista = [randint(0, maxValor) for r in range(largoLista)]
+
+    listaMerge = lista[:]
+    listaHeap = lista[:]
+    listaQuick = lista[:]
+    listaShell = lista[:]
+
+    t1 = time.process_time()  # seteamos el tiempo al empezar
+    mergeSort(listaMerge)  # ejecutamos el algoritmo mergeSort
+    acumulaMerge += time.process_time()-t1  # acumulamos el tiempo de ejecucion
+
+    t1 = time.process_time()  # seteamos el tiempo al empezar
+    heapSort(listaHeap)  # ejecutamos el algoritmo heapSort
+    acumulaHeap += time.process_time()-t1  # acumulamos el tiempo de ejecucion
+
+    t1 = time.process_time()  # seteamos el tiempo al empezar
+    quickSort(listaQuick)  # ejecutamos el algoritmo quickSort
+    acumulaQuick += time.process_time()-t1  # acumulamos el tiempo de ejecucion
+
+    t1 = time.process_time()  # seteamos el tiempo al empezar
+    shellSort(listaShell)  # ejecutamos el algoritmo shellSort
+    acumulaShell += time.process_time()-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")