#83 quicksort_decreasing

Author: wojtask

src/solutions/chapter7/section1/exercise4.py

@@ -0,0 +1,41 @@
+from book.data_structures import Array
+from book.data_structures import CT
+from util import range_of
+
+
+def partition_decreasing(A: Array[CT], p: int, r: int) -> int:
+    """Partitions an array into two subarrays, the low side and the high side, such that each element in the low side of
+    the partition is greater than or equal to the pivot value, which is, in turn, greater than or equal to each element
+    in the high side.
+
+    Args:
+        A: an Array to partition
+        p: the lower index of the subarray to partition
+        r: the upper index of the subarray to partition
+
+    Returns:
+        The index q, such that each element in A[p:q - 1] is greater than or equal to A[q], and that A[q] is greater
+        than or equal to each element in A[q + 1:r].
+    """
+    x = A[r]
+    i = p - 1
+    for j in range_of(p, to=r - 1):
+        if A[j] >= x:
+            i += 1
+            A[i], A[j] = A[j], A[i]
+    A[i + 1], A[r] = A[r], A[i + 1]
+    return i + 1
+
+
+def quicksort_decreasing(A: Array[CT], p: int, r: int) -> None:
+    """Sorts an array into monotonically decreasing order using quicksort.
+
+    Args:
+        A: an Array containing the values to be sorted
+        p: the lower index of the subarray to sort
+        r: the upper index of the subarray to sort
+    """
+    if p < r:
+        q = partition_decreasing(A, p, r)
+        quicksort_decreasing(A, p, q - 1)
+        quicksort_decreasing(A, q + 1, r)

test/test_solutions/test_chapter7.py

@@ -1,4 +1,5 @@
 import math
+import operator
 
 from hypothesis import given
 from hypothesis import strategies as st
@@ -7,6 +8,7 @@
 from hypothesis.strategies import lists
 
 from solutions.chapter7.section1.exercise2 import fair_partition
+from solutions.chapter7.section1.exercise4 import quicksort_decreasing
 from test_case import ClrsTestCase
 from test_util import create_array
 from util import range_of
@@ -41,3 +43,14 @@ def test_fair_partition_all_values_equal(self, data):
         actual_split_index = fair_partition(A, 1, n)
 
         self.assertEqual(actual_split_index, (n + 1) // 2)
+
+    @given(st.data())
+    def test_quicksort_decreasing(self, data):
+        elements = data.draw(lists(integers(), min_size=1))
+        A = create_array(elements)
+        n = len(elements)
+
+        quicksort_decreasing(A, 1, n)
+
+        self.assertArraySorted(A, end=n, cmp=operator.ge)
+        self.assertArrayPermuted(A, elements, end=n)