Count Repetitions

other/clrs/07/01/02.py

@@ -10,13 +10,15 @@ def partition(numbers, start = 0, end = None):
 
         if value == pivot_value:
             repetitions += 1
+        else:
+            repetitions = 0;
 
         if value <= pivot_value:
             numbers[pivot], numbers[i] = numbers[i], numbers[pivot]
             pivot += 1
 
     numbers[pivot], numbers[last] = numbers[last], numbers[pivot]
-    return pivot - repetitions // 2
+    return (pivot + 1) - repetitions // 2
 
 def quicksort(numbers, start = 0, end = None):
     end = end if end else len(numbers)

other/clrs/07/02/03.markdown

@@ -2,6 +2,6 @@
 > contains distict elements and is sorted in decreasing order.
 
 In this case `PARTITION` always returns $p$ because all the elements are
-greated than the pivot. While the **if** will never be executed, we still get
+greater than the pivot. While the **if** will never be executed, we still get
 one empty partition and the recurrence is $T(n) = T(n-1) + \Theta(n)$ (even if
 its body is not executed, the **for** is still $\Theta(n)$).

other/clrs/07/02/04.markdown

@@ -1,7 +1,7 @@
 > Banks often record transactions on an account in order of the times of the
 > transactions, but many people like to receive their bank statements with
 > checks listed in order by check numbers. People usually write checks in order
-> by check number, and merchants usually cash the with reasonable dispatch. The
+> by check number, and merchants usually cash them with reasonable dispatch. The
 > problem of converting time-of-transaction ordering to check-number ordering
 > is therefore the problem of sorting almost-sorted input. Argue that the
 > procedure `INSERTION-SORT` would tend to beat the procedure `QUICKSORT` on
@@ -14,6 +14,6 @@ The more sorted the array is, the less work insertion sort will do. Namely,
 the array. In the example above the number of inversions tends to be small so
 insertion sort will be close to linear.
 
-On the other hand, if `PARTITION` does picks a pivot that does not participate
-in an inversion, it will produce and empty partition. Since there is a small
+On the other hand, if `PARTITION` does pick a pivot that does not participate
+in an inversion, it will produce an empty partition. Since there is a small
 number of inversions, `QUICKSORT` is very likely to produce empty partitions.