Proper changes to sorting.py

.vscode/PythonImportHelper-v2-Completion.json

+[
+    {
+        "label": "time",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "time",
+        "description": "time",
+        "detail": "time",
+        "documentation": {}
+    },
+    {
+        "label": "randint",
+        "importPath": "random",
+        "description": "random",
+        "isExtraImport": true,
+        "detail": "random",
+        "documentation": {}
+    },
+    {
+        "label": "heap",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "heap",
+        "description": "heap",
+        "detail": "heap",
+        "documentation": {}
+    },
+    {
+        "label": "heapify",
+        "kind": 2,
+        "importPath": "heap",
+        "description": "heap",
+        "peekOfCode": "def heapify(lista, n, i):\n\t\t# largest is root for now\n\t\tlargest = i\n\t\t# left child of root\n\t\tleft = 2 * i + 1\n\t\t# right child of root\n\t\tright = 2 * i + 2\n\t\t# Checks if root has a left child and is greater\n\t\t# than root\n\t\tif l < n and lista[i] < lista[l] :",
+        "detail": "heap",
+        "documentation": {}
+    },
+    {
+        "label": "\t\tlargest",
+        "kind": 5,
+        "importPath": "heap",
+        "description": "heap",
+        "peekOfCode": "\t\tlargest = i\n\t\t# left child of root\n\t\tleft = 2 * i + 1\n\t\t# right child of root\n\t\tright = 2 * i + 2\n\t\t# Checks if root has a left child and is greater\n\t\t# than root\n\t\tif l < n and lista[i] < lista[l] :\n\t\t\tlargest = l\n\t\t# Checks if root has a right child and is greater",
+        "detail": "heap",
+        "documentation": {}
+    },
+    {
+        "label": "\t\tleft",
+        "kind": 5,
+        "importPath": "heap",
+        "description": "heap",
+        "peekOfCode": "\t\tleft = 2 * i + 1\n\t\t# right child of root\n\t\tright = 2 * i + 2\n\t\t# Checks if root has a left child and is greater\n\t\t# than root\n\t\tif l < n and lista[i] < lista[l] :\n\t\t\tlargest = l\n\t\t# Checks if root has a right child and is greater\n\t\t# than root\n\t\tif r < n and lista[largest] < lista[r]:",
+        "detail": "heap",
+        "documentation": {}
+    },
+    {
+        "label": "\t\tright",
+        "kind": 5,
+        "importPath": "heap",
+        "description": "heap",
+        "peekOfCode": "\t\tright = 2 * i + 2\n\t\t# Checks if root has a left child and is greater\n\t\t# than root\n\t\tif l < n and lista[i] < lista[l] :\n\t\t\tlargest = l\n\t\t# Checks if root has a right child and is greater\n\t\t# than root\n\t\tif r < n and lista[largest] < lista[r]:\n\t\t\tlargest = r\n\t\t# If necessary, this changes root by swapping va-",
+        "detail": "heap",
+        "documentation": {}
+    },
+    {
+        "label": "\t\t\tlargest",
+        "kind": 5,
+        "importPath": "heap",
+        "description": "heap",
+        "peekOfCode": "\t\t\tlargest = l\n\t\t# Checks if root has a right child and is greater\n\t\t# than root\n\t\tif r < n and lista[largest] < lista[r]:\n\t\t\tlargest = r\n\t\t# If necessary, this changes root by swapping va-\n\t\t# lues\n\t\tlista[i], lista[largest] = lista[largest], lista[i]\n\t\t# This heapifies the root repeatedly\n\t\theapify(lista, n, largest)",
+        "detail": "heap",
+        "documentation": {}
+    },
+    {
+        "label": "\t\t\tlargest",
+        "kind": 5,
+        "importPath": "heap",
+        "description": "heap",
+        "peekOfCode": "\t\t\tlargest = r\n\t\t# If necessary, this changes root by swapping va-\n\t\t# lues\n\t\tlista[i], lista[largest] = lista[largest], lista[i]\n\t\t# This heapifies the root repeatedly\n\t\theapify(lista, n, largest)",
+        "detail": "heap",
+        "documentation": {}
+    },
+    {
+        "label": "mergeSort",
+        "kind": 2,
+        "importPath": "sorting",
+        "description": "sorting",
+        "peekOfCode": "def mergeSort(lista):\n\t# definan el algoritmo de ordenamiento mergesort\n\treturn lista\ndef heapSort(lista):\n\tn = len(lista)\n\th1 = (n // 2) - 1\n\tfor i in range(h1, -1, -1):\n\t\theap.heapify(lista, n, i)\n\tfor i in range(h1, -1, -1):\n\t\tlista[i], lista[0] = lista[0], lista[i]",
+        "detail": "sorting",
+        "documentation": {}
+    },
+    {
+        "label": "heapSort",
+        "kind": 2,
+        "importPath": "sorting",
+        "description": "sorting",
+        "peekOfCode": "def heapSort(lista):\n\tn = len(lista)\n\th1 = (n // 2) - 1\n\tfor i in range(h1, -1, -1):\n\t\theap.heapify(lista, n, i)\n\tfor i in range(h1, -1, -1):\n\t\tlista[i], lista[0] = lista[0], lista[i]\n\t\theap.heapify(lista, i, 0)\n\treturn lista\ndef quickSort(lista):",
+        "detail": "sorting",
+        "documentation": {}
+    },
+    {
+        "label": "quickSort",
+        "kind": 2,
+        "importPath": "sorting",
+        "description": "sorting",
+        "peekOfCode": "def quickSort(lista):\n\t#definan el algoritmo de ordenamiento quicksort\n\treturn lista\ndef shellSort(lista):\n\t#definan el algoritmo de ordenamiento shellsort\n\treturn lista\nmaxValor=1000 \t#define el valor maximo de los elementos de la lista\nlargoLista=1000 \t#define el largo de las listas a ordenar\nveces=100    \t\t#define las veces que se va a hacer el ordenamiento\nacumulaMerge=0 \t#variable para acumular el tiempo de ejecucion del mergesort",
+        "detail": "sorting",
+        "documentation": {}
+    },
+    {
+        "label": "shellSort",
+        "kind": 2,
+        "importPath": "sorting",
+        "description": "sorting",
+        "peekOfCode": "def shellSort(lista):\n\t#definan el algoritmo de ordenamiento shellsort\n\treturn lista\nmaxValor=1000 \t#define el valor maximo de los elementos de la lista\nlargoLista=1000 \t#define el largo de las listas a ordenar\nveces=100    \t\t#define las veces que se va a hacer el ordenamiento\nacumulaMerge=0 \t#variable para acumular el tiempo de ejecucion del mergesort\nacumulaHeap=0 \t#variable para acumular el tiempo de ejecucion del heapsort\nacumulaQuick=0 \t#variable para acumular el tiempo de ejecucion del quicksort\nacumulaShell=0 \t#variable para acumular el tiempo de ejecucion del shellsort",
+        "detail": "sorting",
+        "documentation": {}
+    },
+    {
+        "label": "\tn",
+        "kind": 5,
+        "importPath": "sorting",
+        "description": "sorting",
+        "peekOfCode": "\tn = len(lista)\n\th1 = (n // 2) - 1\n\tfor i in range(h1, -1, -1):\n\t\theap.heapify(lista, n, i)\n\tfor i in range(h1, -1, -1):\n\t\tlista[i], lista[0] = lista[0], lista[i]\n\t\theap.heapify(lista, i, 0)\n\treturn lista\ndef quickSort(lista):\n\t#definan el algoritmo de ordenamiento quicksort",
+        "detail": "sorting",
+        "documentation": {}
+    },
+    {
+        "label": "\th1",
+        "kind": 5,
+        "importPath": "sorting",
+        "description": "sorting",
+        "peekOfCode": "\th1 = (n // 2) - 1\n\tfor i in range(h1, -1, -1):\n\t\theap.heapify(lista, n, i)\n\tfor i in range(h1, -1, -1):\n\t\tlista[i], lista[0] = lista[0], lista[i]\n\t\theap.heapify(lista, i, 0)\n\treturn lista\ndef quickSort(lista):\n\t#definan el algoritmo de ordenamiento quicksort\n\treturn lista",
+        "detail": "sorting",
+        "documentation": {}
+    },
+    {
+        "label": "\tmergelista",
+        "kind": 5,
+        "importPath": "sorting",
+        "description": "sorting",
+        "peekOfCode": "\tmergelista = [randint(0,maxValor) for r in range(largoLista)] #creamos una lista con valores al azar\n\theaplista=list(mergelista)\n\tquicklista=list(mergelista)\n\tsearchlista=list(mergelista)\n\tt1 = time.process_time()\t\t\t\t\t#tomamos el tiempo inicial\n\tmergeSort(mergelista,0,len(mergelista)-1) \t#ejecutamos el algoritmo mergeSort\n\tacumulaMerge+=time.process_time() - t1\t\t#acumulamos el tiempo de ejecucion\n\tprint(mergelista)\t\t\t\t\t\t\t#desplegamos la lista\n\tt1 = time.process_time()\t\t\t\t#tomamos el tiempo inicial\n\theapSort(heaplista)\t\t\t\t\t    #ejecutamos el algoritmo heapSort",
+        "detail": "sorting",
+        "documentation": {}
+    },
+    {
+        "label": "\tt1",
+        "kind": 5,
+        "importPath": "sorting",
+        "description": "sorting",
+        "peekOfCode": "\tt1 = time.process_time()\t\t\t\t\t#tomamos el tiempo inicial\n\tmergeSort(mergelista,0,len(mergelista)-1) \t#ejecutamos el algoritmo mergeSort\n\tacumulaMerge+=time.process_time() - t1\t\t#acumulamos el tiempo de ejecucion\n\tprint(mergelista)\t\t\t\t\t\t\t#desplegamos la lista\n\tt1 = time.process_time()\t\t\t\t#tomamos el tiempo inicial\n\theapSort(heaplista)\t\t\t\t\t    #ejecutamos el algoritmo heapSort\n\tacumulaHeap+=time.process_time() - t1 \t#acumulamos el tiempo de ejecucion\n\tprint(heaplista)\t\t\t\t\t\t#desplegamos la lista\n\tt1 = time.process_time()\t\t\t\t#tomamos el tiempo inicial\n\tquickSort(quicklista)\t\t\t\t\t#ejecutamos el algoritmo quickSort",
+        "detail": "sorting",
+        "documentation": {}
+    },
+    {
+        "label": "\tt1",
+        "kind": 5,
+        "importPath": "sorting",
+        "description": "sorting",
+        "peekOfCode": "\tt1 = time.process_time()\t\t\t\t#tomamos el tiempo inicial\n\theapSort(heaplista)\t\t\t\t\t    #ejecutamos el algoritmo heapSort\n\tacumulaHeap+=time.process_time() - t1 \t#acumulamos el tiempo de ejecucion\n\tprint(heaplista)\t\t\t\t\t\t#desplegamos la lista\n\tt1 = time.process_time()\t\t\t\t#tomamos el tiempo inicial\n\tquickSort(quicklista)\t\t\t\t\t#ejecutamos el algoritmo quickSort\n\tacumulaQuick+=time.process_time() - t1\t#acumulamos el tiempo de ejecucion\n\tprint(quicklista)\t\t\t\t\t\t#desplegamos la lista\n\tt1 = time.process_time()\t\t\t\t#tomamos el tiempo inicial\n\tshellSort(searchlista)\t\t\t\t\t#ejecutamos el algoritmo shellSort",
+        "detail": "sorting",
+        "documentation": {}
+    },
+    {
+        "label": "\tt1",
+        "kind": 5,
+        "importPath": "sorting",
+        "description": "sorting",
+        "peekOfCode": "\tt1 = time.process_time()\t\t\t\t#tomamos el tiempo inicial\n\tquickSort(quicklista)\t\t\t\t\t#ejecutamos el algoritmo quickSort\n\tacumulaQuick+=time.process_time() - t1\t#acumulamos el tiempo de ejecucion\n\tprint(quicklista)\t\t\t\t\t\t#desplegamos la lista\n\tt1 = time.process_time()\t\t\t\t#tomamos el tiempo inicial\n\tshellSort(searchlista)\t\t\t\t\t#ejecutamos el algoritmo shellSort\n\tacumulaShell+=time.process_time() - t1\t#acumulamos el tiempo de ejecucion\n\tprint(searchlista)\t\t\t\t\t\t#desplegamos la lista\n#imprimos los resultados\nprint (\"Promedio de tiempo de ejecucion de \"+ str(veces) +\" listas de largo \" + str(largoLista))",
+        "detail": "sorting",
+        "documentation": {}
+    },
+    {
+        "label": "\tt1",
+        "kind": 5,
+        "importPath": "sorting",
+        "description": "sorting",
+        "peekOfCode": "\tt1 = time.process_time()\t\t\t\t#tomamos el tiempo inicial\n\tshellSort(searchlista)\t\t\t\t\t#ejecutamos el algoritmo shellSort\n\tacumulaShell+=time.process_time() - t1\t#acumulamos el tiempo de ejecucion\n\tprint(searchlista)\t\t\t\t\t\t#desplegamos la lista\n#imprimos los resultados\nprint (\"Promedio de tiempo de ejecucion de \"+ str(veces) +\" listas de largo \" + str(largoLista))\nprint (\"MergeSort \" + str(acumulaMerge/veces) + \" segundos\")\nprint (\"HeapSort \" + str(acumulaHeap/veces) + \" segundos\")\nprint (\"QuickSort \" + str(acumulaQuick/veces) + \" segundos\")\nprint (\"ShellSort \" + str(acumulaShell/veces) + \" segundos\")",
+        "detail": "sorting",
+        "documentation": {}
+    }
+]

sorting.py

 La variable veces define las veces que se va a hacer el ordenamiento
 Al final se imprimen los promedios de cada algortimo
 """
-from random import randint
 import time
-from heap import heap
+from random import randint
+
+import heap
 
 # Python program for implementation of MergeSort
 
 	n = len(lista)
 	h1 = (n // 2) - 1
 	for i in range(h1, -1, -1):
-		heapify(lista, n, i)
+		heap.heapify(lista, n, i)
 
 	for i in range(h1, -1, -1):
 		lista[i], lista[0] = lista[0], lista[i]
-		heapify(lista, i, 0)
+		heap.heapify(lista, i, 0)
 
 	return lista