typo in sorting notebook

Lectures/.ipynb_checkpoints/Sorting Lecture-checkpoint.ipynb

@@ -296,7 +296,7 @@
     "3. Use another sorting algorithm on each non-empty bucket\n",
     "4. Iterate over the buckets in order and put the elements back into the original array.\n",
     "\n",
-    "We can use any other sorting algorithm in sorting each bucket. We could use insertion sort as it has been proven to be close to linear time on extremely small arrays. However you are free to use any other sorting algorithm instead: quicksort, mergesort, event bucketsort again (although is starts to become radix sort at that point). The question here is how to chose the number of buckets. The number of buckets we chose actually affects the running time of the algorithm. Worst-case is that all the elements are put into one bucket resulting in O($N^2$). While the average case is O($N + \\frac{N^2}{k} + k$) where k is the number of buckets, we get O(N) when k=n. So it would be best to create n buckets when sorting. Another question is how to we decide which element goes into which bucket. For this we will define something called a divider. There are multiple ways to define a divider, a few examples are $\\frac{max-min}{num\\_buckets}$ and $\\frac{max}{num\\_buckets}$.<br>\n",
+    "We can use any other sorting algorithm in sorting each bucket. We could use insertion sort as it has been proven to be close to linear time on extremely small arrays. However you are free to use any other sorting algorithm instead: quicksort, mergesort, even bucketsort again (although is starts to become radix sort at that point). The question here is how to chose the number of buckets. The number of buckets we chose actually affects the running time of the algorithm. Worst-case is that all the elements are put into one bucket resulting in O($N^2$). While the average case is O($N + \\frac{N^2}{k} + k$) where k is the number of buckets, we get O(N) when k=n. So it would be best to create n buckets when sorting. Another question is how to we decide which element goes into which bucket. For this we will define something called a divider. There are multiple ways to define a divider, a few examples are $\\frac{max-min}{num\\_buckets}$ and $\\frac{max}{num\\_buckets}$.<br>\n",
     "Lets look at an implementation of bucket sort:\n",
     "```python\n",
     "def bucket_sort(arr, num_buckets=None):\n",
@@ -311,7 +311,7 @@
     "        \n",
     "    # assign each element to a bucket\n",
     "    for x in arr:\n",
-    "        b = x // size # use // to take the floor\n",
+    "        b = x // divider # use // to take the floor\n",
     "        \n",
     "        # if b == num_buckets then assign it to num_buckets - 1\n",
     "        if b == num_buckets:\n",

Lectures/Sorting Lecture.ipynb

@@ -296,7 +296,7 @@
     "3. Use another sorting algorithm on each non-empty bucket\n",
     "4. Iterate over the buckets in order and put the elements back into the original array.\n",
     "\n",
-    "We can use any other sorting algorithm in sorting each bucket. We could use insertion sort as it has been proven to be close to linear time on extremely small arrays. However you are free to use any other sorting algorithm instead: quicksort, mergesort, event bucketsort again (although is starts to become radix sort at that point). The question here is how to chose the number of buckets. The number of buckets we chose actually affects the running time of the algorithm. Worst-case is that all the elements are put into one bucket resulting in O($N^2$). While the average case is O($N + \\frac{N^2}{k} + k$) where k is the number of buckets, we get O(N) when k=n. So it would be best to create n buckets when sorting. Another question is how to we decide which element goes into which bucket. For this we will define something called a divider. There are multiple ways to define a divider, a few examples are $\\frac{max-min}{num\\_buckets}$ and $\\frac{max}{num\\_buckets}$.<br>\n",
+    "We can use any other sorting algorithm in sorting each bucket. We could use insertion sort as it has been proven to be close to linear time on extremely small arrays. However you are free to use any other sorting algorithm instead: quicksort, mergesort, even bucketsort again (although is starts to become radix sort at that point). The question here is how to chose the number of buckets. The number of buckets we chose actually affects the running time of the algorithm. Worst-case is that all the elements are put into one bucket resulting in O($N^2$). While the average case is O($N + \\frac{N^2}{k} + k$) where k is the number of buckets, we get O(N) when k=n. So it would be best to create n buckets when sorting. Another question is how to we decide which element goes into which bucket. For this we will define something called a divider. There are multiple ways to define a divider, a few examples are $\\frac{max-min}{num\\_buckets}$ and $\\frac{max}{num\\_buckets}$.<br>\n",
     "Lets look at an implementation of bucket sort:\n",
     "```python\n",
     "def bucket_sort(arr, num_buckets=None):\n",
@@ -311,7 +311,7 @@
     "        \n",
     "    # assign each element to a bucket\n",
     "    for x in arr:\n",
-    "        b = x // size # use // to take the floor\n",
+    "        b = x // divider # use // to take the floor\n",
     "        \n",
     "        # if b == num_buckets then assign it to num_buckets - 1\n",
     "        if b == num_buckets:\n",