Implement stable_partition.

clibraries · clibraries · commit 443558d1cd65 · 2023-07-15T23:07:49.000-06:00
diff --git a/array_alg.h b/array_alg.h
@@ -441,11 +441,36 @@ ALGDEF T *NS(partition)(
         void *predicate_ctx
         );
 
-ALGDEF T *NS(partition_copy)(
+/// Partition a range by copying the elements that satisfy a predicate into one buffer,
+/// and the ones that fail to another.
+/// Note that this function is stable.
+ALGDEF void NS(partition_copy)(
         const T *first,
         const T *last,
-        T *restrict out_false,
-        T *restrict out_true,
+        T **out_true,
+        T **out_false,
+        int (*predicate)(const T*, void*),
+        void *predicate_ctx
+        );
+
+/// Calls malloc.
+ALGDEF T *NS(stable_partition)(
+        T *first,
+        T *last,
+        int (*predicate)(const T*, void*),
+        void *predicate_ctx
+        );
+
+/// Like above, but does not call `malloc`.
+/// You must provide a buffer.
+/// requires:
+/// - sizeof(buffer) >= the number of false entries in the range [first, last)
+//    Note that sizeof(buffer) >= last - first will be sufficient.
+
+ALGDEF T *NS(stable_partition_with_buffer)(
+        T *first,
+        T *last,
+        T *buffer,
         int (*predicate)(const T*, void*),
         void *predicate_ctx
         );
@@ -644,17 +669,16 @@ ALGDEF void NS(insertion_sort_stable)(
 
 /// Sort an array in a stable way with a merge sort variety.
 /// By stable, we mean that the order of equivalent elements is preserved.
-/// Note this function allocates memory with malloc.
-
+/// Calls malloc.
 ALGDEF void NS(stable_sort)(
         T* first,
         T* last,
         int (*compare)(const T*, const T*, void*),
         void* compare_ctx
         );
 
-/// Like above, but does not call `malloc`.
-/// You provide a buffer.`
+/// Like above, but does not call malloc.
+/// You must provide a buffer.
 /// requires:
 /// - sizeof(buffer) >= (last - first) / 2
 ALGDEF void NS(stable_sort_with_buffer)(
@@ -766,6 +790,7 @@ ALGDEF T *NS(_merge_sort_adaptive_with_buffer_n)(
         void* compare_ctx
         );
 
+
 #ifdef ARRAY_ALG_IMPLEMENTATION
 
 ALGDEF T *NS(find_if)(
@@ -1515,11 +1540,41 @@ ALGDEF T *NS(partition)(
     return out;
 }
 
-ALGDEF T *NS(partition_copy)(
+ALGDEF T *NS(stable_partition_with_buffer)(
+        T *first,
+        T *last,
+        T *buffer,
+        int (*predicate)(const T*, void*),
+        void *predicate_ctx
+        )
+{
+    T *out_false = buffer;
+    T *out_true = first;
+    NS(partition_copy)(first, last, &out_true, &out_false, predicate, predicate_ctx);
+    memcpy(out_true, buffer, sizeof(T) * (out_false - buffer));
+    return out_true;
+}
+
+ALGDEF T *NS(stable_partition)(
+        T *first,
+        T *last,
+        int (*predicate)(const T*, void*),
+        void *predicate_ctx
+        )
+{
+    // TODO: this is not the best implementation 
+    if (first == last) return last;
+    T *buffer = malloc((last - first) * sizeof(T));
+    T *point = NS(stable_partition_with_buffer)(first, last, buffer, predicate, predicate_ctx);
+    free(buffer);
+    return point;
+}
+
+ALGDEF void NS(partition_copy)(
         const T *first,
         const T *last,
-        T *restrict out_false,
-        T *restrict out_true,
+        T **out_true,
+        T **out_false,
         int (*predicate)(const T*, void*),
         void *predicate_ctx
         ) {
@@ -1528,19 +1583,19 @@ ALGDEF T *NS(partition_copy)(
     {
         if (predicate(first, predicate_ctx))
         {
-            *out_true = *first;
-            ++out_true;
+            *(*out_true) = *first;
+            ++(*out_true);
         }
         else
         {
-            *out_false = *first;
-            ++out_false;
+            *(*out_false) = *first;
+            ++(*out_false);
         }
         ++first;
     }
-    return out_false;
 }
 
+
 ALGDEF T *NS(partition_point_n)(
         const T *first,
         size_t n,
diff --git a/test/tests.c b/test/tests.c
@@ -390,9 +390,15 @@ void test_partition(void) {
         int numbers[] = { 1, 2, 3, 4, 5, 6};
         int odd[3];
         int even[3];
-        int* false_end = intv_partition_copy(numbers, numbers + 6, odd, even, pred_is_even, NULL);
 
-        assert(false_end - odd == 3);
+
+        int *out_odd = odd;
+        int *out_even = even;
+
+        intv_partition_copy(numbers, numbers + 6, &out_even, &out_odd, pred_is_even, NULL);
+
+        assert(out_odd - odd == 3);
+        assert(out_even - even == 3);
 
         for (int i = 0; i < 3; ++i) {
             assert(odd[i] % 2 == 1); 
@@ -401,6 +407,19 @@ void test_partition(void) {
     }
 }
 
+void test_stable_partition(void) {
+    int numbers[] = { 1, 2, 3, 4, 5, 6};
+    int *point = intv_stable_partition(numbers, numbers + 6, pred_is_even, NULL);
+
+    assert(point - numbers == 3);
+
+    int expected[] = { 2, 4, 6, 1, 3, 5 };
+
+    for (int i = 0; i < ARRAY_LEN(numbers); ++i) {
+        assert(numbers[i] == expected[i]);
+    }
+}
+
 void test_is_sorted(void) {
     {
         int numbers[] = { 1, 2, 3, 4, 5, 6};
@@ -840,6 +859,7 @@ int main() {
     printf("-- test_minmax --\n"); test_minmax();
     printf("-- test_minmax_element --\n"); test_minmax_element();
     printf("-- test_partition --\n"); test_partition();
+    printf("-- test_stable_partition --\n"); test_stable_partition();
     printf("-- test_is_sorted --\n"); test_is_sorted();
     printf("-- test_binary_search --\n"); test_binary_search();
     printf("-- test_permutation --\n"); test_permutation();
