Chapter_06_Heapsort/exercises_6.2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.2 Maintaining the heap property"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.2-1\n",
    "\n",
    "> Using Figure 6.2 as a model, illustrate the operation of MAX-HEAPIFY$(A, 3)$ on the array $A = \\left \\langle 27, 17, 3, 16, 13, 10, 1, 5, 7, 12, 4, 8, 9, 0 \\right \\rangle$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "MAX-HEAPIFY$(A, 3)$: $A[3] = 3, A[6] = 10, A[7] = 1$, swap $A[3]$ and $A[6]$.\n",
    "\n",
    "![](img/6.2-1_1.png)\n",
    "\n",
    "$A = \\left \\langle 27, 17, 10, 16, 13, 3, 1, 5, 7, 12, 4, 8, 9, 0 \\right \\rangle$\n",
    "\n",
    "![](img/6.2-1_2.png)\n",
    "\n",
    "MAX-HEAPIFY$(A, 6)$: $A[6] = 3, A[12] = 8, A[13] = 9$, swap $A[6]$ and $A[13]$.\n",
    "\n",
    "![](img/6.2-1_3.png)\n",
    "\n",
    "$A = \\left \\langle 27, 17, 10, 16, 13, 9, 1, 5, 7, 12, 4, 8, 3, 0 \\right \\rangle$\n",
    "\n",
    "MAX-HEAPIFY$(A, 13)$: $A[13] = 3$, done."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.2-2\n",
    "\n",
    "> Starting with the procedure MAX-HEAPIFY, write pseudocode for the procedure MIN-HEAPIFY$(A, i)$, which performs the corresponding manipulation on a minheap. How does the running time of MIN-HEAPIFY compare to that of MAX-HEAPIFY?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parent(i):\n",
    "    return (i - 1) >> 1\n",
    "\n",
    "\n",
    "def left(i):\n",
    "    return (i << 1) + 1\n",
    "\n",
    "\n",
    "def right(i):\n",
    "    return (i << 1) + 2\n",
    "\n",
    "\n",
    "def min_heapify(a, i):\n",
    "    min_idx = i\n",
    "    l, r = left(i), right(i)\n",
    "    if l < len(a) and a[l] < a[min_idx]:\n",
    "        min_idx = l\n",
    "    if r < len(a) and a[r] < a[min_idx]:\n",
    "        min_idx = r\n",
    "    if min_idx != i:\n",
    "        a[i], a[min_idx] = a[min_idx], a[i]\n",
    "        min_heapify(a, min_idx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Running time is the same."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.2-3\n",
    "\n",
    "> What is the effect of calling MAX-HEAPIFY$(A, 3)$ when the element $A[i]$ is larger than its children?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No effect."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.2-4\n",
    "\n",
    "> What is the effect of calling MAX-HEAPIFY$(A, 3)$ for $i > A.heap\\text{-}size=2$?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No effect."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.2-5\n",
    "\n",
    "> The code for MAX-HEAPIFY is quite efficient in terms of constant factors, except possibly for the recursive call in line 10, which might cause some compilers to produce inefficient code. Write an efficient MAX-HEAPIFY that uses an iterative control construct (a loop) instead of recursion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def max_heapify(a, i):\n",
    "    while True:\n",
    "        max_idx = i\n",
    "        l, r = left(i), right(i)\n",
    "        if l < len(a) and a[l] > a[max_idx]:\n",
    "            max_idx = l\n",
    "        if r < len(a) and a[r] > a[max_idx]:\n",
    "            max_idx = r\n",
    "        if max_idx == i:\n",
    "            break\n",
    "        a[i], a[max_idx] = a[max_idx], a[i]\n",
    "        i = max_idx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.2-6\n",
    "\n",
    "> Show that the worst-case running time of MAX-HEAPIFY on a heap of size $n$ is $\\Omega(\\lg n)$. (Hint: For a heap with $n$ nodes, give node values that cause MAX-HEAPIFY to be called recursively at every node on a simple path from the root down to a leaf.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The height is $\\left \\lfloor \\lg n \\right \\rfloor$."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}