Modified heap.py and sorting.py

.vscode/PythonImportHelper-v2-Completion.json

         "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] :",
+        "peekOfCode": "def heapify(lista, n, i):\n\t# largest is root for now\n\tlargest = i\n\t# left child of root\n\tl = 2 * i + 1\n\t# right child of root\n\tr = 2 * i + 2\n\t# Checks if root has a left child and is greater\n\t# than root\n\tif l < n and lista[i] < lista[l] :",
         "detail": "heap",
         "documentation": {}
     },
     {
-        "label": "\t\tlargest",
+        "label": "\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",
+        "peekOfCode": "\tlargest = i\n\t# left child of root\n\tl = 2 * i + 1\n\t# right child of root\n\tr = 2 * i + 2\n\t# Checks if root has a left child and is greater\n\t# than root\n\tif l < n and lista[i] < lista[l] :\n\t\tlargest = l\n\t# Checks if root has a right child and is greater",
         "detail": "heap",
         "documentation": {}
     },
     {
-        "label": "\t\tleft",
+        "label": "\tl",
         "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]:",
+        "peekOfCode": "\tl = 2 * i + 1\n\t# right child of root\n\tr = 2 * i + 2\n\t# Checks if root has a left child and is greater\n\t# than root\n\tif l < n and lista[i] < lista[l] :\n\t\tlargest = l\n\t# Checks if root has a right child and is greater\n\t# than root\n\tif r < n and lista[largest] < lista[r]:",
         "detail": "heap",
         "documentation": {}
     },
     {
-        "label": "\t\tright",
+        "label": "\tr",
         "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-",
+        "peekOfCode": "\tr = 2 * i + 2\n\t# Checks if root has a left child and is greater\n\t# than root\n\tif l < n and lista[i] < lista[l] :\n\t\tlargest = l\n\t# Checks if root has a right child and is greater\n\t# than root\n\tif r < n and lista[largest] < lista[r]:\n\t\tlargest = r\n\t# If necessary, this changes root by swapping va-",
         "detail": "heap",
         "documentation": {}
     },
     {
-        "label": "\t\t\tlargest",
+        "label": "\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)",
+        "peekOfCode": "\t\tlargest = l\n\t# Checks if root has a right child and is greater\n\t# than root\n\tif r < n and lista[largest] < lista[r]:\n\t\tlargest = r\n\t# If necessary, this changes root by swapping va-\n\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",
+        "label": "\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)",
+        "peekOfCode": "\t\tlargest = r\n\t# If necessary, this changes root by swapping va-\n\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": {}
     },
         "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]",
+        "peekOfCode": "def mergeSort(lista, l, r):\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\th2 = n - 1\n\tfor i in range(h2, 0, -1):",
         "detail": "sorting",
         "documentation": {}
     },
         "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):",
+        "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\th2 = n - 1\n\tfor i in range(h2, 0, -1):\n\t\tlista[i], lista[0] = lista[0], lista[i]\n\t\theap.heapify(lista, 0, i)\n\treturn lista",
         "detail": "sorting",
         "documentation": {}
     },
         "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",
+        "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\th2 = n - 1\n\tfor i in range(h2, 0, -1):\n\t\tlista[i], lista[0] = lista[0], lista[i]\n\t\theap.heapify(lista, 0, i)\n\treturn lista\ndef quickSort(lista):",
         "detail": "sorting",
         "documentation": {}
     },
         "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",
+        "peekOfCode": "\th1 = (n // 2) - 1\n\tfor i in range(h1, -1, -1):\n\t\theap.heapify(lista, n, i)\n\th2 = n - 1\n\tfor i in range(h2, 0, -1):\n\t\tlista[i], lista[0] = lista[0], lista[i]\n\t\theap.heapify(lista, 0, i)\n\treturn lista\ndef quickSort(lista):\n\t#definan el algoritmo de ordenamiento quicksort",
+        "detail": "sorting",
+        "documentation": {}
+    },
+    {
+        "label": "\th2",
+        "kind": 5,
+        "importPath": "sorting",
+        "description": "sorting",
+        "peekOfCode": "\th2 = n - 1\n\tfor i in range(h2, 0, -1):\n\t\tlista[i], lista[0] = lista[0], lista[i]\n\t\theap.heapify(lista, 0, i)\n\treturn lista\ndef quickSort(lista):\n\t#definan el algoritmo de ordenamiento quicksort\n\treturn lista\ndef shellSort(lista):\n\t#definan el algoritmo de ordenamiento shellsort",
         "detail": "sorting",
         "documentation": {}
     },

heap.py

 # i. Also, n is the size of a heap and arr is array.
 
 def heapify(lista, n, i):
-		# largest is root for now
-		largest = i
+	# largest is root for now
+	largest = i
 
-		# left child of root
-		left = 2 * i + 1
+	# left child of root
+	l = 2 * i + 1
 
-		# right child of root
-		right = 2 * i + 2
+	# right child of root
+	r = 2 * i + 2
 
-		# Checks if root has a left child and is greater
-		# than root
-		if l < n and lista[i] < lista[l] :
-			largest = l
+	# Checks if root has a left child and is greater
+	# than root
+	if l < n and lista[i] < lista[l] :
+		largest = l
 
-		# Checks if root has a right child and is greater
-		# than root
-		if r < n and lista[largest] < lista[r]:
-			largest = r
+	# Checks if root has a right child and is greater
+	# than root
+	if r < n and lista[largest] < lista[r]:
+		largest = r
 
-		# If necessary, this changes root by swapping va-
-		# lues
+	# If necessary, this changes root by swapping va-
+	# lues
 		lista[i], lista[largest] = lista[largest], lista[i]
 
 		# This heapifies the root repeatedly

sorting.py

 # First subarray is arr[l..m]
 # Second subarray is arr[m+1..r]
 
-def mergeSort(lista):
+def mergeSort(lista, l, r):
 	# definan el algoritmo de ordenamiento mergesort
 	return lista
 
 	for i in range(h1, -1, -1):
 		heap.heapify(lista, n, i)
 
-	for i in range(h1, -1, -1):
+	h2 = n - 1
+	for i in range(h2, 0, -1):
 		lista[i], lista[0] = lista[0], lista[i]
-		heap.heapify(lista, i, 0)
+		heap.heapify(lista, 0, i)
 
 	return lista