Lab/Lecture_02/L02_Sorting_no_sols.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Advanced Sorting Algorithms: QuickSort and Merge Sort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Define some function useful for testing\n",
    "import random\n",
    "\n",
    "## generate an array of n random integers up to 10000\n",
    "def get_random_array(n):\n",
    "    return [random.randint(0, 10000) for _ in range(n)]\n",
    "\n",
    "def test_sorting_algorithm(algorithm):\n",
    "    for _ in range(100):\n",
    "        A = get_random_array(random.randint(0, 1000))\n",
    "        A_sorted = algorithm(A)\n",
    "        assert A_sorted == sorted(A), \"FAIL!\"\n",
    "        \n",
    "# testing testing function\n",
    "test_sorting_algorithm(sorted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## QuickSort \n",
    "\n",
    "Quicksort is a divide-and-conquer algorithm. It works by selecting a 'pivot' element from the array and partitioning the other elements into two sub-arrays, according to whether they are less than or greater than the pivot. The sub-arrays are then sorted recursively. This can be done **in-place**, requiring small additional amounts of memory to perform the sorting.\n",
    "\n",
    "Thus, the most important part of QuickSort is its partition algorithm. \n",
    "Given a pivot element, the partition algorithm splits a subarray into three parts.\n",
    "\n",
    "- Elements that are smaller than or equal to the pivot\n",
    "- The pivot\n",
    "- Elements that are greater than or equal to the pivot\n",
    "\n",
    "The algorithm works in-place, i.e., it performs the partition within the subarray itself without any extra space."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![alt text](partition_algorithm.png \"Partition: pseudocode\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![alt text](partition_figure.png \"Figure\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![alt text](partition_running_example.png \"Title\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: binary vector\n",
    "You are given a binary vector, i.e., each element is either 0 or 1. Implements an easy variant of partition to sort the vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "import random \n",
    "\n",
    "binary = [random.randint(0,1) for _ in range(20)]\n",
    "print(binary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Your implementation goes here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: QuickSort\n",
    "Below an implementation of QuickSort. \n",
    "\n",
    "In this exercise you have to:\n",
    "- Write detailed comments to describe crucial parts of the code below (to prove you have understand it)\n",
    "- Implement a random selection of the pivot element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def partition(A, low, high): \n",
    "    pivot = A[high]\n",
    "    i = low-1\n",
    "  \n",
    "    for j in range(low, high): \n",
    "        if A[j] <= pivot: \n",
    "            i = i+1 \n",
    "            A[i], A[j] = A[j], A[i] \n",
    "  \n",
    "    A[i+1], A[high] = A[high], A[i+1] \n",
    "    return i+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quickSort_rec(A, low, high):\n",
    "    if low < high: \n",
    "        pi = partition(A, low, high) \n",
    "        quickSort_rec(A, low, pi-1) \n",
    "        quickSort_rec(A, pi+1, high) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quickSort(B):\n",
    "    A = B[:] # Copy the array just because we decided to return a sorted copy of the original array \n",
    "    quickSort_rec(A, 0, len(A)-1)\n",
    "    return A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quickSort([2, 1, 4, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_sorting_algorithm(quickSort)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's do some experiments\n",
    "\n",
    "Is QuickSort faster than InsertionSort and SelectionSort in practice?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "T(n) = T(n-1) + c*n\n",
    "\n",
    "Theta(n^2) worst case\n",
    "\n",
    "T(n) = 2T(n/2) + c*n \n",
    "\n",
    "Theta(n log n) best case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def insertionSort(coll):\n",
    "    A = list(coll)\n",
    "    for i in range(1, len(A)):\n",
    "        curr = A[i]\n",
    "        j = i-1\n",
    "        while j >= 0 and curr < A[j]:\n",
    "            A[j+1] = A[j]\n",
    "            j -= 1\n",
    "        A[j+1] = curr\n",
    "    return A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def selectionSort(coll):\n",
    "    A = list(coll)\n",
    "    for i in range(len(A)): \n",
    "        # Find the minimum element in remaining unsorted array \n",
    "        min_idx = i \n",
    "        for j in range(i+1, len(A)): \n",
    "            if A[min_idx] > A[j]: \n",
    "                min_idx = j \n",
    "\n",
    "        # Swap the found minimum element with  \n",
    "        # the first element         \n",
    "        A[i], A[min_idx] = A[min_idx], A[i]\n",
    "    return A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = get_random_array(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.02 ms ± 16.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit quickSort(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40.4 ms ± 280 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit insertionSort(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35.8 ms ± 246 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit selectionSort(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### More than 20x faster with arrays of length 1000. \n",
    "\n",
    "Try to run the experiments with an array of 10000. **Run insertion sort and selection sort just before you go to sleep.** "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's see how time changes by increasing the length of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.21 µs ± 21.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n",
      "646 ns ± 3.04 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n",
      "1.32 µs ± 31.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n",
      "3.14 µs ± 71.3 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n",
      "1.48 µs ± 7.51 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n",
      "2.57 µs ± 83.6 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n",
      "6.33 µs ± 92.1 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n",
      "2.87 µs ± 61.5 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n",
      "5.76 µs ± 98.2 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n",
      "11.6 µs ± 223 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n",
      "11.7 µs ± 216 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n",
      "14.6 µs ± 246 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n",
      "35.3 µs ± 426 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "33.4 µs ± 343 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "42.1 µs ± 438 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "65.9 µs ± 514 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "155 µs ± 2.65 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "152 µs ± 4.82 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "155 µs ± 1.64 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "519 µs ± 12.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "541 µs ± 10.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "351 µs ± 6.83 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "2.04 ms ± 35.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n",
      "1.96 ms ± 61.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "784 µs ± 6.66 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "9.1 ms ± 275 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n",
      "8.62 ms ± 75.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n",
      "1.91 ms ± 38.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "39 ms ± 1.21 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
      "33.9 ms ± 275 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "qs_t = []\n",
    "is_t = []\n",
    "ss_t = []\n",
    "\n",
    "lens = [2**i for i in range(1, 11)]\n",
    "\n",
    "for n in lens:\n",
    "    A = get_random_array(n)\n",
    "    result = %timeit -o quickSort(A)\n",
    "    qs_t.append( result.best )\n",
    "    result = %timeit -o insertionSort(A)\n",
    "    is_t.append( result.best )\n",
    "    result = %timeit -o selectionSort(A)\n",
    "    ss_t.append( result.best )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "UsageError: unrecognized arguments: # any cell within the notebook that creates a plot will embed a PNG image of the resulting graphic\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt # standard way to import\n",
    "\n",
    "%matplotlib inline # any cell within the notebook that creates a plot will embed a PNG image of the resulting graphic\n",
    "plt.rcParams[\"figure.figsize\"] = (20,10)\n",
    "plt.style.use('ggplot')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "\n",
    "ax.plot(lens, qs_t, \"g--\", label=\"QuickSort\")\n",
    "ax.plot(lens, is_t, \"r--\", label=\"InsertionSort\")\n",
    "ax.plot(lens, ss_t, \"b--\", label=\"SelectionSort\")\n",
    "\n",
    "_ = ax.legend(loc=\"best\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Merge Sort\n",
    "Merge Sort is an efficient, general-purpose, comparison-based sorting algorithm. Most implementations produce a **stable sort**, which means that the order of equal elements is the same in the input and output. \n",
    "\n",
    "Merge sort is a divide and conquer algorithm that was invented by John von Neumann in 1945.\n",
    "\n",
    "Below a running example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![alt text](mergesort_figure.png \"Title\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: Merge Sort\n",
    "Complete the implementation of Merge Sort by implementing function ```merge()```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Your implementation goes here\n",
    "\n",
    "def merge(A, l, m, r): \n",
    "  ## TODO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mergeSort_rec(A, l, r): \n",
    "    \n",
    "    if l < r:       \n",
    "        m = (l+(r-1))//2  # Same as (l+r)//2, but avoids overflow for large l and h \n",
    "    \n",
    "        # Sort first and second halves \n",
    "        mergeSort_rec(A, l, m) \n",
    "        mergeSort_rec(A, m+1, r) \n",
    "        merge(A, l, m, r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mergeSort(B):\n",
    "    A = B[:] # Copy the array just because we decided to return a sorted copy of the original array \n",
    "    mergeSort_rec(A, 0, len(A))\n",
    "    return A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_sorting_algorithm(mergeSort)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = get_random_array(10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit quickSort(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit mergeSort(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B B B | G G G | G G G | B B B\n",
    "\n",
    "B B | G G G |                   G G G | B B B "
   ]
  }
 ],
 "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.8.5"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}