Açıklama Yok

sorting.py 5.5KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166
  1. """
  2. Carlos J Corrada Bravo
  3. Este programa calcula el promedio de tiempo de ejecucion de cuatro algoritmos de ordenamiento
  4. La variable maxValor define el valor maximo de los elementos de la lista
  5. La variable largoLista define el largo de las listas a ordenar
  6. La variable veces define las veces que se va a hacer el ordenamiento
  7. Al final se imprimen los promedios de cada algortimo
  8. """
  9. from random import randint
  10. import time
  11. def mergeSort(lista):
  12. #definan el algoritmo de ordenamiento mergesort
  13. # se vieron videos y se leyo sobre el algoritmo en GeekforGeeks, educative.io y medium.com el codigo fue basado en esto
  14. # si tiene al menos un elemento
  15. if len(lista) > 1:
  16. # buscar mitad de lista
  17. middle = len(lista)//2
  18. # llamada recursiva de mitad izq de lista
  19. Left = mergeSort(lista[:middle])
  20. # llamada recursiva de mitad derecha de lista
  21. Right = mergeSort(lista[middle:])
  22. # return y llamada recursiva merge para combinar ambas listas
  23. return merge(Right, Left, lista)
  24. # se devuelve cuando solamente haya un elemento
  25. return lista
  26. def merge(Right, Left, lista):
  27. # acumuladores
  28. i = 0
  29. j = 0
  30. k = 0
  31. # comparar las dos listas y ordenar de manera ascendiente
  32. while i < len(Left) and j < len(Right):
  33. # si el elemento de la izq es menor que la derecha
  34. # añadelo a la lista
  35. if Left[i] < Right[j]:
  36. lista[k] = Left[i]
  37. i += 1
  38. k += 1
  39. # si el elemento de la derecha es menor que la derecha
  40. # añadelo a la lista
  41. else:
  42. lista[k] = Right[j]
  43. j += 1
  44. k += 1
  45. # si quedan elementos en la lista izq añadelos en la lista
  46. while i < len(Left):
  47. lista[k] = Left[i]
  48. i += 1
  49. k += 1
  50. # si quedan elementos en la lista derecha añadelos en la lista
  51. while j < len(Right):
  52. lista[k] = Right[j]
  53. j += 1
  54. k += 1
  55. return lista
  56. def heapSort(lista):
  57. #trabajado por Andrel Fuentes
  58. #definan el algoritmo de ordenamiento heapsort
  59. #crear el "max heap"
  60. for i in range(largoLista // 2, -1, -1):
  61. heapify(lista, largoLista, i)
  62. for i in range(largoLista - 1, 0, -1):
  63. lista[i], lista[0] = lista[0], lista[i]
  64. heapify(lista, i, 0)
  65. return lista
  66. def quickSort(lista):
  67. # definan el algoritmo de ordenamiento quicksort
  68. return lista
  69. def shellSort(lista):
  70. # definan el algoritmo de ordenamiento shellsort
  71. div = len(lista) / 2
  72. # verifica si no se puede dividir mas
  73. while div != 0:
  74. # dividir lista en sub listas
  75. for j in range(div):
  76. # hacer insertion sort en sub listas
  77. for x in range(div + j, len(lista), div):
  78. key = lista[x]
  79. pos = x - div
  80. while pos >= 0 and key < lista[pos]:
  81. lista[pos + div] = lista[pos]
  82. pos -= div
  83. lista[pos + div] = key
  84. div /= 2
  85. return lista
  86. def heapify(lista, largo, raiz):
  87. #trabajado por Andrel Fuentes
  88. #encontrar cual el valor mayor entre de los hijos y raiz
  89. #define las posiciones de los hijos
  90. largest_value = raiz
  91. left_child = raiz * 2 + 1
  92. right_child = raiz * 2 + 2
  93. #se verifica si el hijo izquierdo es mayor, actualizar variable de mayor
  94. #si fuera necesario
  95. if left_child < largoLista and lista[left_child] > lista[raiz]:
  96. largest_value = left_child
  97. #se verifica si el hijo derecho es mayor, actualizar variable de mayor
  98. #si fuera necesario
  99. if right_child < largoLista and lista[right_child] > lista[largest_value]:
  100. largest_value = right_child
  101. #se verifica si la posicion inicial sigue siendo la misma/mayor, swap si necesario
  102. #y continuar con heapify
  103. if largest_value != raiz:
  104. lista[raiz], lista[largest_value] = lista[largest_value], lista[raiz]
  105. heapify(lista, largo, largest_value)
  106. maxValor=1000 #define el valor maximo de los elementos de la lista
  107. largoLista=1000 #define el largo de las listas a ordenar
  108. veces=100 #define las veces que se va a hacer el ordenamiento
  109. acumulaMerge=0 #variable para acumular el tiempo de ejecucion del mergesort
  110. acumulaHeap=0 #variable para acumular el tiempo de ejecucion del heapsort
  111. acumulaQuick=0 #variable para acumular el tiempo de ejecucion del quicksort
  112. acumulaShell=0 #variable para acumular el tiempo de ejecucion del shellsort
  113. for i in range(veces):
  114. mergelista = [randint(0,maxValor) for r in range(largoLista)] # creamos una lista con valores al azar
  115. heaplista = list(mergelista)
  116. quicklista = list(mergelista)
  117. searchlista = list(mergelista)
  118. t1 = time.process_time() #seteamos el tiempo al empezar
  119. mergeSort(mergelista) #ejecutamos el algoritmo mergeSort
  120. acumulaMerge+=time.process_time()-t1 #acumulamos el tiempo de ejecucion
  121. t1 = time.process_time() #seteamos el tiempo al empezar
  122. heapSort(heaplista) #ejecutamos el algoritmo heapSort
  123. acumulaHeap+=time.process_time()-t1 #acumulamos el tiempo de ejecucion
  124. t1 = time.process_time() #seteamos el tiempo al empezar
  125. quickSort(quicklista) #ejecutamos el algoritmo quickSort
  126. acumulaQuick+=time.process_time()-t1 #acumulamos el tiempo de ejecucion
  127. t1 = time.process_time() #seteamos el tiempo al empezar
  128. shellSort(searchlista) #ejecutamos el algoritmo shellSort
  129. acumulaShell+=time.process_time()-t1 #acumulamos el tiempo de ejecucion
  130. #imprimos los resultados
  131. print ("Promedio de tiempo de ejecucion de "+ str(veces) +" listas de largo " + str(largoLista))
  132. print ("MergeSort " + str(acumulaMerge/veces) + " segundos")
  133. print ("HeapSort " + str(acumulaHeap/veces) + " segundos")
  134. print ("QuickSort " + str(acumulaQuick/veces) + " segundos")
  135. print ("ShellSort " + str(acumulaShell/veces) + " segundos")