Optimiser F1 avec un tri fusion en O(n log n)

tests/test_banque.c

@@ -0,0 +1,62 @@
+/* Cas limites et comparaisons avec des algorithmes de référence simples. */
+#define main banque_main
+#include "../banque.c"
+#undef main
+
+#include <assert.h>
+#include <limits.h>
+
+static int comparer_reference(const void *a, const void *b)
+{
+    const Transaction *ta = a;
+    const Transaction *tb = b;
+    if (ta->montant < tb->montant)
+        return -1;
+    if (ta->montant > tb->montant)
+        return 1;
+    if (ta->id < tb->id)
+        return -1;
+    return ta->id > tb->id;
+}
+
+static void verifier_tri(Transaction *t, int n)
+{
+    Transaction attendu[128];
+    assert(n <= 128);
+    memcpy(attendu, t, (size_t)n * sizeof(*t));
+    qsort(attendu, (size_t)n, sizeof(*attendu), comparer_reference);
+    trier_par_montant(t, n);
+    for (int i = 0; i < n; i++) {
+        assert(t[i].id == attendu[i].id);
+        assert(t[i].client == attendu[i].client);
+        assert(t[i].jour == attendu[i].jour);
+        assert(t[i].montant == attendu[i].montant);
+    }
+}
+
+static void tester_tri(void)
+{
+    trier_par_montant(NULL, 0);
+    Transaction limites[] = {
+        {INT_MAX, 1, 2, LONG_MAX}, {3, 4, 5, 0},
+        {INT_MIN, 6, 7, LONG_MIN}, {1, 8, 9, 0}, {2, 10, 11, LONG_MAX}
+    };
+    verifier_tri(limites, 5);
+    verifier_tri(limites, 5); /* déjà trié */
+    Transaction t[128];
+    for (int n = 1; n <= 128; n++) {
+        for (int i = 0; i < n; i++)
+            t[i] = (Transaction){n - i, i, i + 1, (i * 37) % 11 - 5};
+        verifier_tri(t, n);
+        for (int i = 0; i < n; i++)
+            t[i] = (Transaction){i, i, i + 1, n - i};
+        verifier_tri(t, n); /* ordre inverse */
+    }
+}
+
+int main(void)
+{
+    tester_tri();
+    puts("Tests banque : OK");
+    return 0;
+}