Modified heap.py and sorting.py

.vscode/PythonImportHelper-v2-Completion.json

         "kind": 2,
         "importPath": "heap",
         "description": "heap",
-        "peekOfCode": "def heapify(lista, n, i):\n\tlargest = i # Initialize largest as root\n\tl = 2 * i + 1 # left = 2*i + 1\n\tr = 2 * i + 2 # right = 2*i + 2\n\t# See if left child of root exists and is\n\t# greater than root\n\tif l < n and lista[i] < lista[l]:\n\t\tlargest = l\n\t# See if right child of root exists and is\n\t# greater than root",
+        "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": "\tlargest",
+        "label": "\t\tlargest",
         "kind": 5,
         "importPath": "heap",
         "description": "heap",
-        "peekOfCode": "\tlargest = i # Initialize largest as root\n\tl = 2 * i + 1 # left = 2*i + 1\n\tr = 2 * i + 2 # right = 2*i + 2\n\t# See if left child of root exists and is\n\t# greater than root\n\tif l < n and lista[i] < lista[l]:\n\t\tlargest = l\n\t# See if right child of root exists and is\n\t# greater than root\n\tif r < n and lista[largest] < lista[r]:",
+        "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": "\tl",
+        "label": "\t\tleft",
         "kind": 5,
         "importPath": "heap",
         "description": "heap",
-        "peekOfCode": "\tl = 2 * i + 1 # left = 2*i + 1\n\tr = 2 * i + 2 # right = 2*i + 2\n\t# See if left child of root exists and is\n\t# greater than root\n\tif l < n and lista[i] < lista[l]:\n\t\tlargest = l\n\t# See if right child of root exists and is\n\t# greater than root\n\tif r < n and lista[largest] < lista[r]:\n\t\tlargest = r",
+        "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": "\tr",
+        "label": "\t\tright",
         "kind": 5,
         "importPath": "heap",
         "description": "heap",
-        "peekOfCode": "\tr = 2 * i + 2 # right = 2*i + 2\n\t# See if left child of root exists and is\n\t# greater than root\n\tif l < n and lista[i] < lista[l]:\n\t\tlargest = l\n\t# See if right child of root exists and is\n\t# greater than root\n\tif r < n and lista[largest] < lista[r]:\n\t\tlargest = r\n\t# Change root, if needed",
+        "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\tlargest",
+        "label": "\t\t\tlargest",
         "kind": 5,
         "importPath": "heap",
         "description": "heap",
-        "peekOfCode": "\t\tlargest = l\n\t# See if right child of root exists and is\n\t# greater than root\n\tif r < n and lista[largest] < lista[r]:\n\t\tlargest = r\n\t# Change root, if needed\n\tif largest != i:\n\t\t(lista[i], lista[largest]) = (lista[largest], lista[i]) # swap\n\t\t# Heapify the root.\n\t\theapify(lista, n, largest)",
+        "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\theapify(lista, n, largest)",
         "detail": "heap",
         "documentation": {}
     },
     {
-        "label": "\t\tlargest",
+        "label": "\t\t\tlargest",
         "kind": 5,
         "importPath": "heap",
         "description": "heap",
-        "peekOfCode": "\t\tlargest = r\n\t# Change root, if needed\n\tif largest != i:\n\t\t(lista[i], lista[largest]) = (lista[largest], lista[i]) # swap\n\t\t# Heapify the root.\n\t\theapify(lista, n, largest)",
+        "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\theapify(lista, n, largest)",
         "detail": "heap",
         "documentation": {}
     },
     {
+        "label": "heapify",
+        "kind": 2,
+        "importPath": "heap_BACKUP_341",
+        "description": "heap_BACKUP_341",
+        "peekOfCode": "def heapify(lista, n, i):\n<<<<<<< HEAD\n\tlargest = i # Initialize largest as root\n\tl = 2 * i + 1 # left = 2*i + 1\n\tr = 2 * i + 2 # right = 2*i + 2\n\t# See if left child of root exists and is\n\t# greater than root\n\tif l < n and lista[i] < lista[l]:\n\t\tlargest = l\n\t# See if right child of root exists and is",
+        "detail": "heap_BACKUP_341",
+        "documentation": {}
+    },
+    {
+        "label": "\tlargest",
+        "kind": 5,
+        "importPath": "heap_BACKUP_341",
+        "description": "heap_BACKUP_341",
+        "peekOfCode": "\tlargest = i # Initialize largest as root\n\tl = 2 * i + 1 # left = 2*i + 1\n\tr = 2 * i + 2 # right = 2*i + 2\n\t# See if left child of root exists and is\n\t# greater than root\n\tif l < n and lista[i] < lista[l]:\n\t\tlargest = l\n\t# See if right child of root exists and is\n\t# greater than root\n\tif r < n and lista[largest] < lista[r]:",
+        "detail": "heap_BACKUP_341",
+        "documentation": {}
+    },
+    {
+        "label": "\tl",
+        "kind": 5,
+        "importPath": "heap_BACKUP_341",
+        "description": "heap_BACKUP_341",
+        "peekOfCode": "\tl = 2 * i + 1 # left = 2*i + 1\n\tr = 2 * i + 2 # right = 2*i + 2\n\t# See if left child of root exists and is\n\t# greater than root\n\tif l < n and lista[i] < lista[l]:\n\t\tlargest = l\n\t# See if right child of root exists and is\n\t# greater than root\n\tif r < n and lista[largest] < lista[r]:\n\t\tlargest = r",
+        "detail": "heap_BACKUP_341",
+        "documentation": {}
+    },
+    {
+        "label": "\tr",
+        "kind": 5,
+        "importPath": "heap_BACKUP_341",
+        "description": "heap_BACKUP_341",
+        "peekOfCode": "\tr = 2 * i + 2 # right = 2*i + 2\n\t# See if left child of root exists and is\n\t# greater than root\n\tif l < n and lista[i] < lista[l]:\n\t\tlargest = l\n\t# See if right child of root exists and is\n\t# greater than root\n\tif r < n and lista[largest] < lista[r]:\n\t\tlargest = r\n\t# Change root, if needed",
+        "detail": "heap_BACKUP_341",
+        "documentation": {}
+    },
+    {
+        "label": "\t\tlargest",
+        "kind": 5,
+        "importPath": "heap_BACKUP_341",
+        "description": "heap_BACKUP_341",
+        "peekOfCode": "\t\tlargest = l\n\t# See if right child of root exists and is\n\t# greater than root\n\tif r < n and lista[largest] < lista[r]:\n\t\tlargest = r\n\t# Change root, if needed\n=======\n\t# largest is root for now\n\tlargest = i\n\t# left child of root",
+        "detail": "heap_BACKUP_341",
+        "documentation": {}
+    },
+    {
+        "label": "\t\tlargest",
+        "kind": 5,
+        "importPath": "heap_BACKUP_341",
+        "description": "heap_BACKUP_341",
+        "peekOfCode": "\t\tlargest = r\n\t# Change root, if needed\n=======\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",
+        "detail": "heap_BACKUP_341",
+        "documentation": {}
+    },
+    {
+        "label": "\tlargest",
+        "kind": 5,
+        "importPath": "heap_BACKUP_341",
+        "description": "heap_BACKUP_341",
+        "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_BACKUP_341",
+        "documentation": {}
+    },
+    {
+        "label": "\tl",
+        "kind": 5,
+        "importPath": "heap_BACKUP_341",
+        "description": "heap_BACKUP_341",
+        "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_BACKUP_341",
+        "documentation": {}
+    },
+    {
+        "label": "\tr",
+        "kind": 5,
+        "importPath": "heap_BACKUP_341",
+        "description": "heap_BACKUP_341",
+        "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_BACKUP_341",
+        "documentation": {}
+    },
+    {
+        "label": "\t\tlargest",
+        "kind": 5,
+        "importPath": "heap_BACKUP_341",
+        "description": "heap_BACKUP_341",
+        "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>>>>>>> sortingHeap\n\tif largest != i:",
+        "detail": "heap_BACKUP_341",
+        "documentation": {}
+    },
+    {
+        "label": "\t\tlargest",
+        "kind": 5,
+        "importPath": "heap_BACKUP_341",
+        "description": "heap_BACKUP_341",
+        "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>>>>>>> sortingHeap\n\tif largest != i:\n\t\t(lista[i], lista[largest]) = (lista[largest], lista[i]) # swap\n\t\t# Heapify the root.\n\t\theapify(lista, n, largest)",
+        "detail": "heap_BACKUP_341",
+        "documentation": {}
+    },
+    {
+        "label": "heapify",
+        "kind": 2,
+        "importPath": "heap_BASE_341",
+        "description": "heap_BASE_341",
+        "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_BASE_341",
+        "documentation": {}
+    },
+    {
+        "label": "\t\tlargest",
+        "kind": 5,
+        "importPath": "heap_BASE_341",
+        "description": "heap_BASE_341",
+        "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_BASE_341",
+        "documentation": {}
+    },
+    {
+        "label": "\t\tleft",
+        "kind": 5,
+        "importPath": "heap_BASE_341",
+        "description": "heap_BASE_341",
+        "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_BASE_341",
+        "documentation": {}
+    },
+    {
+        "label": "\t\tright",
+        "kind": 5,
+        "importPath": "heap_BASE_341",
+        "description": "heap_BASE_341",
+        "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_BASE_341",
+        "documentation": {}
+    },
+    {
+        "label": "\t\t\tlargest",
+        "kind": 5,
+        "importPath": "heap_BASE_341",
+        "description": "heap_BASE_341",
+        "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_BASE_341",
+        "documentation": {}
+    },
+    {
+        "label": "\t\t\tlargest",
+        "kind": 5,
+        "importPath": "heap_BASE_341",
+        "description": "heap_BASE_341",
+        "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_BASE_341",
+        "documentation": {}
+    },
+    {
+        "label": "heapify",
+        "kind": 2,
+        "importPath": "heap_LOCAL_341",
+        "description": "heap_LOCAL_341",
+        "peekOfCode": "def heapify(lista, n, i):\n\tlargest = i # Initialize largest as root\n\tl = 2 * i + 1 # left = 2*i + 1\n\tr = 2 * i + 2 # right = 2*i + 2\n\t# See if left child of root exists and is\n\t# greater than root\n\tif l < n and lista[i] < lista[l]:\n\t\tlargest = l\n\t# See if right child of root exists and is\n\t# greater than root",
+        "detail": "heap_LOCAL_341",
+        "documentation": {}
+    },
+    {
+        "label": "\tlargest",
+        "kind": 5,
+        "importPath": "heap_LOCAL_341",
+        "description": "heap_LOCAL_341",
+        "peekOfCode": "\tlargest = i # Initialize largest as root\n\tl = 2 * i + 1 # left = 2*i + 1\n\tr = 2 * i + 2 # right = 2*i + 2\n\t# See if left child of root exists and is\n\t# greater than root\n\tif l < n and lista[i] < lista[l]:\n\t\tlargest = l\n\t# See if right child of root exists and is\n\t# greater than root\n\tif r < n and lista[largest] < lista[r]:",
+        "detail": "heap_LOCAL_341",
+        "documentation": {}
+    },
+    {
+        "label": "\tl",
+        "kind": 5,
+        "importPath": "heap_LOCAL_341",
+        "description": "heap_LOCAL_341",
+        "peekOfCode": "\tl = 2 * i + 1 # left = 2*i + 1\n\tr = 2 * i + 2 # right = 2*i + 2\n\t# See if left child of root exists and is\n\t# greater than root\n\tif l < n and lista[i] < lista[l]:\n\t\tlargest = l\n\t# See if right child of root exists and is\n\t# greater than root\n\tif r < n and lista[largest] < lista[r]:\n\t\tlargest = r",
+        "detail": "heap_LOCAL_341",
+        "documentation": {}
+    },
+    {
+        "label": "\tr",
+        "kind": 5,
+        "importPath": "heap_LOCAL_341",
+        "description": "heap_LOCAL_341",
+        "peekOfCode": "\tr = 2 * i + 2 # right = 2*i + 2\n\t# See if left child of root exists and is\n\t# greater than root\n\tif l < n and lista[i] < lista[l]:\n\t\tlargest = l\n\t# See if right child of root exists and is\n\t# greater than root\n\tif r < n and lista[largest] < lista[r]:\n\t\tlargest = r\n\t# Change root, if needed",
+        "detail": "heap_LOCAL_341",
+        "documentation": {}
+    },
+    {
+        "label": "\t\tlargest",
+        "kind": 5,
+        "importPath": "heap_LOCAL_341",
+        "description": "heap_LOCAL_341",
+        "peekOfCode": "\t\tlargest = l\n\t# See if right child of root exists and is\n\t# greater than root\n\tif r < n and lista[largest] < lista[r]:\n\t\tlargest = r\n\t# Change root, if needed\n\tif largest != i:\n\t\t(lista[i], lista[largest]) = (lista[largest], lista[i]) # swap\n\t\t# Heapify the root.\n\t\theapify(lista, n, largest)",
+        "detail": "heap_LOCAL_341",
+        "documentation": {}
+    },
+    {
+        "label": "\t\tlargest",
+        "kind": 5,
+        "importPath": "heap_LOCAL_341",
+        "description": "heap_LOCAL_341",
+        "peekOfCode": "\t\tlargest = r\n\t# Change root, if needed\n\tif largest != i:\n\t\t(lista[i], lista[largest]) = (lista[largest], lista[i]) # swap\n\t\t# Heapify the root.\n\t\theapify(lista, n, largest)",
+        "detail": "heap_LOCAL_341",
+        "documentation": {}
+    },
+    {
+        "label": "heapify",
+        "kind": 2,
+        "importPath": "heap_REMOTE_341",
+        "description": "heap_REMOTE_341",
+        "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_REMOTE_341",
+        "documentation": {}
+    },
+    {
+        "label": "\tlargest",
+        "kind": 5,
+        "importPath": "heap_REMOTE_341",
+        "description": "heap_REMOTE_341",
+        "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_REMOTE_341",
+        "documentation": {}
+    },
+    {
+        "label": "\tl",
+        "kind": 5,
+        "importPath": "heap_REMOTE_341",
+        "description": "heap_REMOTE_341",
+        "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_REMOTE_341",
+        "documentation": {}
+    },
+    {
+        "label": "\tr",
+        "kind": 5,
+        "importPath": "heap_REMOTE_341",
+        "description": "heap_REMOTE_341",
+        "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_REMOTE_341",
+        "documentation": {}
+    },
+    {
+        "label": "\t\tlargest",
+        "kind": 5,
+        "importPath": "heap_REMOTE_341",
+        "description": "heap_REMOTE_341",
+        "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_REMOTE_341",
+        "documentation": {}
+    },
+    {
+        "label": "\t\tlargest",
+        "kind": 5,
+        "importPath": "heap_REMOTE_341",
+        "description": "heap_REMOTE_341",
+        "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_REMOTE_341",
+        "documentation": {}
+    },
+    {
         "label": "merge",
         "kind": 2,
         "importPath": "merge",
         "kind": 2,
         "importPath": "sorting",
         "description": "sorting",
-        "peekOfCode": "def mergeSort(lista, l, r):\n\tif l < r:\n      # Same as (l+r)//2, but avoids overflow for\n      # large l and h\n\t\tm = l+(r-l)//2\n      # Sort first and second halves\n\t\tmergeSort(lista, l, m)\n\t\tmergeSort(lista, m+1, r)\n\t\tmerge(lista, l, m, r)\n''' Luis Andrés López Mañán",
+        "peekOfCode": "def mergeSort(lista, l, r):\n<<<<<<< HEAD\n\tif l < r:\n      # Same as (l+r)//2, but avoids overflow for\n      # large l and h\n\t\tm = l+(r-l)//2\n      # Sort first and second halves\n\t\tmergeSort(lista, l, m)\n\t\tmergeSort(lista, m+1, r)\n\t\tmerge(lista, l, m, r)",
         "detail": "sorting",
         "documentation": {}
     },
         "kind": 5,
         "importPath": "sorting",
         "description": "sorting",
-        "peekOfCode": "\tn = len(lista)\n\theap.heapify(lista,n,0)\n\t''' Se crea un heap máximo y el último padre estará en\n\t\tla posición h1, i.e., la mitad del tamaño de la lista.\n\t\tPor lo tanto, ese sería el comienzo. \n\t'''\n\th1 = (n // 2) - 1\n\tfor i in range(h1, -1, -1):\n\t\theap.heapify(lista, n, i)\n\t# Se extrae los elementos uno a uno",
+        "peekOfCode": "\tn = len(lista)\n\theap.heapify(lista,n,0)\n\t''' Se crea un heap máximo y el último padre estará en\n\t\tla posición h1, i.e., la mitad del tamaño de la lista.\n\t\tPor lo tanto, ese sería el comienzo. \n\t'''\n\th1 = (n // 2) - 1\n\tfor i in range(h1, -1, -1):\n\t\theap.heapify(lista, n, i)\n<<<<<<< HEAD",
         "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\t# Se extrae los elementos uno a uno\n\th2 = n - 1\n\tfor i in range(h2, 0, -1):\n\t\t# Se intercambia, luego se hace heapify\n\t\tlista[i], lista[0] = lista[0], lista[i]\n\t\theap.heapify(lista, 0, i)\n\treturn lista",
+        "peekOfCode": "\th1 = (n // 2) - 1\n\tfor i in range(h1, -1, -1):\n\t\theap.heapify(lista, n, i)\n<<<<<<< HEAD\n\t# Se extrae los elementos uno a uno\n\th2 = n - 1\n\tfor i in range(h2, 0, -1):\n\t\t# Se intercambia, luego se hace heapify\n\t\tlista[i], lista[0] = lista[0], lista[i]\n\t\theap.heapify(lista, 0, i)",
+        "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\t# Se intercambia, luego se hace heapify\n\t\tlista[i], lista[0] = lista[0], lista[i]\n\t\theap.heapify(lista, 0, i)\n=======\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)",
         "detail": "sorting",
         "documentation": {}
     },
         "kind": 5,
         "importPath": "sorting",
         "description": "sorting",
-        "peekOfCode": "\th2 = n - 1\n\tfor i in range(h2, 0, -1):\n\t\t# Se intercambia, luego se hace heapify\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\telements = len(lista)\n    # Base case",
+        "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>>>>>>> sortingHeap\n\treturn lista\ndef quickSort(lista):\n\t# definan el algoritmo de ordenamiento quicksort\n\telements = len(lista)\n    # Base case",
         "detail": "sorting",
         "documentation": {}
     },

heap.py

 # i. Also, n is the size of a heap and arr is array.
 
 def heapify(lista, n, i):
-	largest = i # Initialize largest as root
-	l = 2 * i + 1 # left = 2*i + 1
-	r = 2 * i + 2 # right = 2*i + 2
+		# largest is root for now
+		largest = i
 
-	# See if left child of root exists and is
-	# greater than root
+		# left child of root
+		left = 2 * i + 1
 
-	if l < n and lista[i] < lista[l]:
-		largest = l
+		# right child of root
+		right = 2 * i + 2
 
-	# See if right child of root exists and is
-	# greater than root
+		# Checks if root has a left child and is greater
+		# than root
+		if l < n and lista[i] < lista[l] :
+			largest = l
 
-	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
 
-	# Change root, if needed
-
-	if largest != i:
-		(lista[i], lista[largest]) = (lista[largest], lista[i]) # swap
-
-		# Heapify the root.
+		# If necessary, this changes root by swapping va-
+		# lues
+		lista[i], lista[largest] = lista[largest], lista[i]
 
 		heapify(lista, n, largest)

sorting.py

 La variable veces define las veces que se va a hacer el ordenamiento
 La variable veces define las veces que se va a hacer el ordenamiento
 Al final se imprimen los promedios de cada algortimo
+<<<<<<< HEAD
 '''
 
+=======
+"""
+>>>>>>> sortingHeap
 import time
 from random import randint
 
 import heap
+<<<<<<< HEAD
 from merge import merge
+=======
+>>>>>>> sortingHeap
 
 # Python program for implementation of MergeSort
 
 # Second subarray is arr[m+1..r]
 
 def mergeSort(lista, l, r):
+<<<<<<< HEAD
 	if l < r:
       # Same as (l+r)//2, but avoids overflow for
       # large l and h
 '''
 
 # Python program for implementation of heap Sort (Part II)
+=======
+	# definan el algoritmo de ordenamiento mergesort
+	return lista
+>>>>>>> sortingHeap
 
 def heapSort(lista):
 	# Se busca el tamaño de la lista
 	h1 = (n // 2) - 1
 	for i in range(h1, -1, -1):
 		heap.heapify(lista, n, i)
+<<<<<<< HEAD
   
 	# Se extrae los elementos uno a uno
 	h2 = n - 1
 		lista[i], lista[0] = lista[0], lista[i]
 		heap.heapify(lista, 0, i)
   
+=======
+
+	h2 = n - 1
+	for i in range(h2, 0, -1):
+		lista[i], lista[0] = lista[0], lista[i]
+		heap.heapify(lista, 0, i)
+
+>>>>>>> sortingHeap
 	return lista
 
 def quickSort(lista):