sorting.py

@@ -11,11 +11,71 @@ from random import randint
 import time
 
 def mergeSort(lista):
+        #Camila Vazquez Rodriguez
 	#definan el algoritmo de ordenamiento mergesort
-	return lista
+        if len(lista) > 1:
+                mid = len(lista)//2
+                L = lista[:mid]
+                R = lista[mid:]
+
+                mergeSort(L)
+                mergeSort(R)
+
+                i = 0
+                j = 0
+                k = 0
+
+        while i < len(L) and j < len(R):
+                if L[i] <= R[j]:
+                        lista[k] = L[i]
+                        i += 1
+                else:
+                        lista[k] = R[j]
+                        j += 1
+                k += 1
+
+        while i < len(L):
+                lista[k] = L[i]
+                i += 1
+                k += 1
+
+        while j < len(R):
+                lista[k] = R[j]
+                j += 1
+                k += 1
+
+        return lista
 
 def heapSort(lista):
 	#definan el algoritmo de ordenamiento heapsort
+	"""
+	Carlos Hernández
+	Implementación de heapSort.
+	"""
+	def max_heapify(lista, idx, heap_size):
+		"""Convertir el nodo `idx` y sus descendientes en un max heap."""
+		left_idx = 2 * idx + 1
+		right_idx = 2 * idx + 2
+		largestval_idx = idx
+		if left_idx < heap_size and lista[idx] < lista[left_idx]:
+			largestval_idx = left_idx
+		if right_idx < heap_size and lista[largestval_idx] < lista[right_idx]:
+			largestval_idx = right_idx
+		if largestval_idx != idx:
+			lista[idx], lista[largestval_idx] = lista[largestval_idx], lista[idx]
+			max_heapify(lista, largestval_idx, heap_size)
+
+	def build_max_heap(lista, heap_size):
+		"""Construir un max heap the un heap dado."""
+		for idx in range((heap_size - 1) // 2, -1, -1):
+			max_heapify(lista, idx, heap_size)
+
+	heap_size = len(lista)
+	build_max_heap(lista, heap_size)
+	for idx in range(len(lista) - 1, 0, -1):
+		lista[0], lista[idx] = lista[idx], lista[0]
+		heap_size -= 1
+		max_heapify(lista, 0, heap_size)
 	return lista
 
 def quickSort(lista):
@@ -45,6 +105,29 @@ def quickSort(lista):
 
 def shellSort(lista):
 	#definan el algoritmo de ordenamiento shellsort
+
+	#El algoritmo compara elementos de una lista
+	#que tienen una distancia fija entre ellos, la
+	#differencia en distancia se minimiza por cada
+	#iterazion del algoritmo
+
+	num = int(len(lista))
+	dif = int(num/2)
+
+	while dif > 0:
+		for i in range(int(dif),int(num)):
+			a = lista[i]
+			j = i
+
+			#por cada intervalo se reorganizara los elementos
+			#si se cumple la declaracion dentro del while loop
+			while j >= dif and lista[int(j - dif)] > a:
+				lista[int(j)] = lista[int(j - dif)]
+				j -= dif
+
+			lista[int(j)] = a
+		dif/= 2
+
 	return lista
 
 maxValor=1000 	#define el valor maximo de los elementos de la lista
@@ -57,33 +140,27 @@ 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
-
-    # creamos copias de la lista para cada algoritmo
-    listaMerge = lista[:]
-    listaHeap = lista[:]
-    listaQuick = lista[:]
-    listaShell = lista[:]
+	lista = [randint(0,maxValor) for r in range(largoLista)] #creamos una lista con valores al azar
 
-    t1 = time.clock()  #seteamos el tiempo al empezar
-    mergeSort(listaMerge)  #ejecutamos el algoritmo mergeSort
-    acumulaMerge+=time.clock()-t1  #acumulamos el tiempo de ejecucion
+	t1 = time.clock() 				#seteamos el tiempo al empezar
+	mergeSort(lista) 				#ejecutamos el algoritmo mergeSort
+	acumulaMerge+=time.clock()-t1 	#acumulamos el tiempo de ejecucion
 
-    t1 = time.clock()  #seteamos el tiempo al empezar
-    heapSort(listaHeap)  #ejecutamos el algoritmo heapSort
-    acumulaHeap+=time.clock()-t1 #acumulamos el tiempo de ejecucion
+	t1 = time.clock()				#seteamos el tiempo al empezar
+	heapSort(lista)					#ejecutamos el algoritmo heapSort
+	acumulaHeap+=time.clock()-t1 	#acumulamos el tiempo de ejecucion
 
-    t1 = time.clock()  #seteamos el tiempo al empezar
-    quickSort(listaQuick)  #ejecutamos el algoritmo quickSort
-    acumulaQuick+=time.clock()-t1  #acumulamos el tiempo de ejecucion
+	t1 = time.clock()				#seteamos el tiempo al empezar
+	quickSort(lista)				#ejecutamos el algoritmo quickSort
+	acumulaQuick+=time.clock()-t1 	#acumulamos el tiempo de ejecucion
 
-    t1 = time.clock()  #seteamos el tiempo al empezar
-    shellSort(listaShell)  #ejecutamos el algoritmo shellSort
-    acumulaShell+=time.clock()-t1  #acumulamos el tiempo de ejecucion
+	t1 = time.clock()				#seteamos el tiempo al empezar
+	shellSort(lista)				#ejecutamos el algoritmo shellSort
+	acumulaShell+=time.clock()-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 ("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")