Refactoring

_main.c

-#include <assert.h>
-// Warning : stdbool
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "bptree.h"
-#include "sorted_array.h"
-
-int main() {
-    BPTreeNode *root = bptree_init(2);
-    int keys_length = 40;
-    uint64_t keys[] = {8, 12, 11, 47, 22, 95, 86, 40, 33, 78, 28, 5, 75, 88, 21, 56, 82, 51, 93, 66, 48, 70, 57, 65, 35, 4, 60, 41, 49, 55, 68, 72, 23, 31, 30, 42, 18, 87, 24, 58};
-    array_print(keys_length, keys);
-
-    for (int i = 0; i < keys_length; i++) {
-        bptree_insert(root, keys[i], keys[i] * 1000);
-    }
-
-    bptree_print(root, 0);
-
-    for (int i = 0; i < keys_length; i++) {
-        uint64_t data;
-        bool found = bptree_search(root, keys[i], &data);
-
-        assert(found == true);
-        assert(data == keys[i] * 1000);
-    }
-
-    bptree_destroy(&root);
-    return EXIT_SUCCESS;
-}

src/Array.c

@@ -5,7 +5,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-int _lower_bound(IntegerArray *array, uint64_t item) {
+int lower_bound(IntegerArray *array, uint64_t item) {
     int low = 0;
     int high = array->size - 1;
 
@@ -38,10 +38,10 @@ void IntegerArray_destroy(IntegerArray **array) {
 }
 
 int IntegerArray_insert_sorted(IntegerArray *array, uint64_t item) {
-    int index = _lower_bound(array, item);
+    int index = lower_bound(array, item);
 
     for (int i = array->size - 1; i >= index; i--) {
-        array[i + 1] = array[i];
+        array->items[i + 1] = array->items[i];
     }
 
     array->items[index] = item;
@@ -51,7 +51,7 @@ int IntegerArray_insert_sorted(IntegerArray *array, uint64_t item) {
 
 void IntegerArray_insert_at_index(IntegerArray *array, int index, uint64_t item) {
     for (int i = array->size - 1; i >= index; i--) {
-        array[i + 1] = array[i];
+        array->items[i + 1] = array->items[i];
     }
 
     array->items[index] = item;
@@ -63,7 +63,7 @@ void IntegerArray_append(IntegerArray *array, uint64_t item) {
     array->size++;
 }
 
-static int _IntegerArray_find_index(IntegerArray *array, uint64_t item) {
+static int IntegerArray_find_index(IntegerArray *array, uint64_t item) {
     int low = 0;
     int high = array->size - 1;
 
@@ -83,7 +83,7 @@ static int _IntegerArray_find_index(IntegerArray *array, uint64_t item) {
 }
 
 bool IntegerArray_binary_search(IntegerArray *array, uint64_t item, int *index) {
-    *index = _IntegerArray_find_index(array, item);
+    *index = IntegerArray_find_index(array, item);
     return *index != -1;
 }
 
@@ -116,7 +116,7 @@ void BPTreeNodeArray_destroy(BPTreeNodeArray **array) {
 
 void BPTreeNodeArray_insert_at_index(BPTreeNodeArray *array, int index, BPTreeNode *item) {
     for (int i = array->size - 1; i >= index; i--) {
-        array[i + 1] = array[i];
+        array->items[i + 1] = array->items[i];
     }
 
     array->items[index] = item;
@@ -130,7 +130,7 @@ void BPTreeNodeArray_append(BPTreeNodeArray *array, BPTreeNode *item) {
 
 void BPTreeNodeArray_delete_at_index(BPTreeNodeArray *array, int index) {
     for (int i = index; i < array->size; i++) {
-        array[i] = array[i + 1];
+        array->items[i] = array->items[i + 1];
     }
 
     array->size--;

src/Array.h

@@ -9,7 +9,7 @@ typedef struct IntegerArray {
     int size;
 } IntegerArray;
 
-int _lower_bound(IntegerArray *array, uint64_t item);
+int lower_bound(IntegerArray *array, uint64_t item);
 
 IntegerArray *IntegerArray_init(int capacity);
 void IntegerArray_destroy(IntegerArray **array);

src/bptree.c

@@ -5,7 +5,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "sorted_array.h"
+#include "Array.h"
 
 // static bool has_minimum_keys(BPTreeNode *node);
 static bool has_maximum_keys(BPTreeNode *node);
@@ -15,30 +15,27 @@ static bool has_maximum_keys(BPTreeNode *node);
 // }
 
 static bool has_maximum_keys(BPTreeNode *node) {
-    return node->keys_length == 2 * node->order;
+    return node->keys->size == 2 * node->order;
 }
 
 BPTreeNode *bptree_init(int order) {
     BPTreeNode *root = (BPTreeNode *)malloc(sizeof(BPTreeNode));
     root->order = order;
     root->is_leaf = true;
-    root->keys_length = 0;
-    root->keys = (uint64_t *)malloc(sizeof(uint64_t) * (2 * order));
-    root->data_length = 0;
-    root->data = (uint64_t *)malloc(sizeof(uint64_t) * (2 * order));
-    root->children_length = 0;
-    root->children = (BPTreeNode **)malloc(sizeof(BPTreeNode *) * (2 * order + 1));
+    root->keys = IntegerArray_init(2 * root->order);
+    root->data = IntegerArray_init(2 * root->order);
+    root->children = BPTreeNodeArray_init(2 * root->order + 1);
     return root;
 }
 
 void bptree_destroy(BPTreeNode **root) {
-    for (int i = 0; i < (*root)->children_length; i++) {
-        bptree_destroy(&(*root)->children[i]);
+    for (int i = 0; i < (*root)->children->size; i++) {
+        bptree_destroy(&(*root)->children->items[i]);
     }
 
-    free((*root)->keys);
-    free((*root)->data);
-    free((*root)->children);
+    IntegerArray_destroy(&(*root)->keys);
+    IntegerArray_destroy(&(*root)->data);
+    BPTreeNodeArray_destroy(&(*root)->children);
     free(*root);
     *root = NULL;
 }
@@ -48,108 +45,117 @@ void bptree_print(BPTreeNode *root, int depth) {
         printf("  ");
     }
 
-    array_print(root->keys_length, root->keys);
+    IntegerArray_print(root->keys);
 
-    for (int i = 0; i < root->children_length; i++) {
-        bptree_print(root->children[i], depth + 1);
+    for (int i = 0; i < root->children->size; i++) {
+        bptree_print(root->children->items[i], depth + 1);
     }
 }
 
 bool bptree_search(BPTreeNode *root, uint64_t key, uint64_t *data) {
     if (root->is_leaf) {
         int index;
-        bool found = sorted_array_search(root->keys_length, root->keys, key, &index);
+        bool found = IntegerArray_binary_search(root->keys, key, &index);
 
         if (found) {
-            *data = root->data[index];
+            *data = root->data->items[index];
         }
 
         return found;
     }
 
-    int child_index = lower_bound(root->keys_length, root->keys, key);
+    int child_index = lower_bound(root->keys, key);
 
-    if (child_index < root->keys_length && root->keys[child_index] == key) {
+    if (child_index < root->keys->size && root->keys->items[child_index] == key) {
         child_index += 1;
     }
 
-    return bptree_search(root->children[child_index], key, data);
+    return bptree_search(root->children->items[child_index], key, data);
 }
 
 // Insertion
 
+static void redistribute_keys(BPTreeNode *left_node, BPTreeNode *right_node, int left_index, int right_index);
+static void redistribute_children(BPTreeNode *left_node, BPTreeNode *right_node, int left_index, int right_index);
+static uint64_t split_internal(BPTreeNode *node, uint64_t key, BPTreeNode *right_child_node, BPTreeNode **right_node);
+static uint64_t split_leaf(BPTreeNode *node, uint64_t key, uint64_t data, BPTreeNode **right_node);
+static void grow(BPTreeNode *root, uint64_t median_value, BPTreeNode *split_right_node);
+static BPTreeNode *find_leaf(BPTreeNode *root, uint64_t key, BPTreeNodeArray **parents);
+static void insert_full(BPTreeNode *root, BPTreeNodeArray *parents, BPTreeNode *node, uint64_t key, uint64_t data, BPTreeNode *previous_split_right_node);
+static void insert_non_full(BPTreeNode *node, uint64_t key, uint64_t data, BPTreeNode *previous_split_right_node);
+
 static void redistribute_keys(BPTreeNode *left_node, BPTreeNode *right_node, int left_index, int right_index) {
-    for (int i = right_index; i < left_node->keys_length; i++) {
-        array_append(&right_node->keys_length, right_node->keys, left_node->keys[i]);
-        array_append(&right_node->data_length, right_node->data, left_node->data[i]);
+    for (int i = right_index; i < left_node->keys->size; i++) {
+        IntegerArray_append(right_node->keys, left_node->keys->items[i]);
+        IntegerArray_append(right_node->data, left_node->data->items[i]);
     }
 
-    left_node->keys_length = left_index;
-    left_node->data_length = left_index;
+    left_node->keys->size = left_index;
+    left_node->data->size = left_index;
 }
 
-static uint64_t split_leaf(BPTreeNode *node, uint64_t key, uint64_t data, BPTreeNode **right_node) {
-    int virtual_insertion_index = lower_bound(node->keys_length, node->keys, key);
-    int median_index = node->keys_length / 2;
+static void redistribute_children(BPTreeNode *left_node, BPTreeNode *right_node, int left_index, int right_index) {
+    for (int i = right_index; i < left_node->children->size; i++) {
+        BPTreeNodeArray_append(right_node->children, left_node->children->items[i]);
+    }
+
+    left_node->children->size = left_index;
+}
+
+static uint64_t split_internal(BPTreeNode *node, uint64_t key, BPTreeNode *right_child_node, BPTreeNode **right_node) {
+    int virtual_insertion_index = lower_bound(node->keys, key);
+    int median_index = node->keys->size / 2;
     uint64_t median_value;
     *right_node = bptree_init(node->order);
+    (*right_node)->is_leaf = false;
 
     if (virtual_insertion_index < median_index) {
-        median_value = node->keys[median_index - 1];
-        redistribute_keys(node, *right_node, median_index - 1, median_index - 1);
-        int insertion_index = sorted_array_insert(&node->keys_length, node->keys, key);
-        array_insert_at_index(&node->data_length, node->data, insertion_index, data);
+        median_value = node->keys->items[median_index - 1];
+        redistribute_keys(node, *right_node, median_index - 1, median_index);
+        redistribute_children(node, *right_node, median_index, median_index);
+        int insertion_index = IntegerArray_insert_sorted(node->keys, key);
+        BPTreeNodeArray_insert_at_index(node->children, insertion_index + 1, right_child_node);
     } else if (virtual_insertion_index > median_index) {
-        median_value = node->keys[median_index];
-        redistribute_keys(node, *right_node, median_index, median_index);
-        int insertion_index = sorted_array_insert(&(*right_node)->keys_length, (*right_node)->keys, key);
-        array_insert_at_index(&(*right_node)->data_length, (*right_node)->data, insertion_index, data);
+        median_value = node->keys->items[median_index];
+        redistribute_keys(node, *right_node, median_index, median_index + 1);
+        redistribute_children(node, *right_node, median_index + 1, median_index + 1);
+        int insertion_index = IntegerArray_insert_sorted((*right_node)->keys, key);
+        BPTreeNodeArray_insert_at_index((*right_node)->children, insertion_index + 1, right_child_node);
     } else {
         median_value = key;
         redistribute_keys(node, *right_node, median_index, median_index);
-        int insertion_index = sorted_array_insert(&(*right_node)->keys_length, (*right_node)->keys, key);
-        array_insert_at_index(&(*right_node)->data_length, (*right_node)->data, insertion_index, data);
+        redistribute_children(node, *right_node, median_index + 1, median_index + 1);
+        BPTreeNodeArray_insert_at_index((*right_node)->children, 0, right_child_node);
     }
 
-    // TODO : Linked List
-
     return median_value;
 }
 
-static void redistribute_children(BPTreeNode *left_node, BPTreeNode *right_node, int left_index, int right_index) {
-    for (int i = right_index; i < left_node->children_length; i++) {
-        array_append_BPTreeNode(&right_node->children_length, right_node->children, left_node->children[i]);
-    }
-
-    left_node->children_length = left_index;
-}
-
-static uint64_t split_internal(BPTreeNode *node, uint64_t key, BPTreeNode *right_child_node, BPTreeNode **right_node) {
-    int virtual_insertion_index = lower_bound(node->keys_length, node->keys, key);
-    int median_index = node->keys_length / 2;
+static uint64_t split_leaf(BPTreeNode *node, uint64_t key, uint64_t data, BPTreeNode **right_node) {
+    int virtual_insertion_index = lower_bound(node->keys, key);
+    int median_index = node->keys->size / 2;
     uint64_t median_value;
     *right_node = bptree_init(node->order);
-    (*right_node)->is_leaf = false;
 
     if (virtual_insertion_index < median_index) {
-        median_value = node->keys[median_index - 1];
-        redistribute_keys(node, *right_node, median_index - 1, median_index);
-        redistribute_children(node, *right_node, median_index, median_index);
-        int insertion_index = sorted_array_insert(&node->keys_length, node->keys, key);
-        array_insert_at_index_BPTreeNode(&node->children_length, node->children, insertion_index + 1, right_child_node);
+        median_value = node->keys->items[median_index - 1];
+        redistribute_keys(node, *right_node, median_index - 1, median_index - 1);
+        int insertion_index = IntegerArray_insert_sorted(node->keys, key);
+        IntegerArray_insert_at_index(node->data, insertion_index, data);
     } else if (virtual_insertion_index > median_index) {
-        median_value = node->keys[median_index];
-        redistribute_keys(node, *right_node, median_index, median_index + 1);
-        redistribute_children(node, *right_node, median_index + 1, median_index + 1);
-        int insertion_index = sorted_array_insert(&(*right_node)->keys_length, (*right_node)->keys, key);
-        array_insert_at_index_BPTreeNode(&(*right_node)->children_length, (*right_node)->children, insertion_index + 1, right_child_node);
+        median_value = node->keys->items[median_index];
+        redistribute_keys(node, *right_node, median_index, median_index);
+        int insertion_index = IntegerArray_insert_sorted((*right_node)->keys, key);
+        IntegerArray_insert_at_index((*right_node)->data, insertion_index, data);
     } else {
         median_value = key;
         redistribute_keys(node, *right_node, median_index, median_index);
-        redistribute_children(node, *right_node, median_index + 1, median_index + 1);
-        array_insert_at_index_BPTreeNode(&(*right_node)->children_length, (*right_node)->children, 0, right_child_node);
+        int insertion_index = IntegerArray_insert_sorted((*right_node)->keys, key);
+        IntegerArray_insert_at_index((*right_node)->data, insertion_index, data);
     }
 
+    // TODO : Linked List
+
     return median_value;
 }
 
@@ -157,30 +163,48 @@ static void grow(BPTreeNode *root, uint64_t median_value, BPTreeNode *split_righ
     BPTreeNode *left_node = bptree_init(root->order);
     left_node->is_leaf = split_right_node->is_leaf;
 
-    for (int i = 0; i < root->keys_length; i++) {
-        array_append(&left_node->keys_length, left_node->keys, root->keys[i]);
+    for (int i = 0; i < root->keys->size; i++) {
+        IntegerArray_append(left_node->keys, root->keys->items[i]);
 
-        if (root->is_leaf) {
-            array_append(&left_node->data_length, left_node->data, root->data[i]);
+        // if (root->is_leaf) {
+        if (left_node->is_leaf) {
+            IntegerArray_append(left_node->data, root->data->items[i]);
         }
     }
 
-    for (int i = 0; i < root->children_length; i++) {
-        array_append_BPTreeNode(&left_node->children_length, left_node->children, root->children[i]);
+    for (int i = 0; i < root->children->size; i++) {
+        BPTreeNodeArray_append(left_node->children, root->children->items[i]);
     }
 
     root->is_leaf = false;
-    root->keys_length = 0;
-    root->children_length = 0;
+    root->keys->size = 0;
+    root->children->size = 0;
 
-    array_append(&root->keys_length, root->keys, median_value);
-    array_append_BPTreeNode(&root->children_length, root->children, left_node);
-    array_append_BPTreeNode(&root->children_length, root->children, split_right_node);
+    IntegerArray_append(root->keys, median_value);
+    BPTreeNodeArray_append(root->children, left_node);
+    BPTreeNodeArray_append(root->children, split_right_node);
 }
 
-static void insert_non_full(BPTreeNode *node, uint64_t key, uint64_t data, BPTreeNode *previous_split_right_node);
+static BPTreeNode *find_leaf(BPTreeNode *root, uint64_t key, BPTreeNodeArray **parents) {
+    BPTreeNode *current = root;
+    // TODO : 10 is not enough.
+    *parents = BPTreeNodeArray_init(10);
 
-static void insert_full(BPTreeNode *root, int *parents_length, BPTreeNode **parents, BPTreeNode *node, uint64_t key, uint64_t data, BPTreeNode *previous_split_right_node) {
+    while (!current->is_leaf) {
+        BPTreeNodeArray_append(*parents, current);
+        int child_index = lower_bound(current->keys, key);
+
+        if (child_index < current->keys->size && current->keys->items[child_index] == key) {
+            child_index += 1;
+        }
+
+        current = current->children->items[child_index];
+    }
+
+    return current;
+}
+
+static void insert_full(BPTreeNode *root, BPTreeNodeArray *parents, BPTreeNode *node, uint64_t key, uint64_t data, BPTreeNode *previous_split_right_node) {
     uint64_t median_value;
     BPTreeNode *split_right_node;
 
@@ -193,11 +217,12 @@ static void insert_full(BPTreeNode *root, int *parents_length, BPTreeNode **pare
     if (node == root) {
         grow(root, median_value, split_right_node);
     } else {
-        BPTreeNode *parent = parents[*parents_length - 1];
-        array_delete_at_index_BPTreeNode(parents_length, parents, *parents_length - 1);
+        BPTreeNode *parent = parents->items[parents->size - 1];
+        BPTreeNodeArray_delete_at_index(parents, parents->size - 1);
 
         if (has_maximum_keys(parent)) {
-            insert_full(root, parents_length, parents, parent, median_value, 0, split_right_node);
+            // 0 is passed instead of data because the recursion is necessarily done on an internal node.
+            insert_full(root, parents, parent, median_value, 0, split_right_node);
         } else {
             insert_non_full(parent, median_value, data, split_right_node);
         }
@@ -205,51 +230,30 @@ static void insert_full(BPTreeNode *root, int *parents_length, BPTreeNode **pare
 }
 
 static void insert_non_full(BPTreeNode *node, uint64_t key, uint64_t data, BPTreeNode *previous_split_right_node) {
-    int insertion_index = sorted_array_insert(&node->keys_length, node->keys, key);
+    int insertion_index = IntegerArray_insert_sorted(node->keys, key);
 
     if (node->is_leaf) {
-        array_insert_at_index(&node->data_length, node->data, insertion_index, data);
+        IntegerArray_insert_at_index(node->data, insertion_index, data);
     }
 
     if (previous_split_right_node != NULL) {
-        array_insert_at_index_BPTreeNode(&node->children_length, node->children, insertion_index + 1, previous_split_right_node);
+        BPTreeNodeArray_insert_at_index(node->children, insertion_index + 1, previous_split_right_node);
     }
 }
 
-static BPTreeNode *find_leaf(BPTreeNode *root, uint64_t key, int *parents_length, BPTreeNode ***parents) {
-    BPTreeNode *current = root;
-    *parents_length = 0;
-    // TODO : 10 is not enough.
-    *parents = (BPTreeNode **)malloc(sizeof(BPTreeNode *) * 10);
-
-    while (!current->is_leaf) {
-        array_append_BPTreeNode(parents_length, *parents, current);
-        int child_index = lower_bound(current->keys_length, current->keys, key);
-
-        if (child_index < current->keys_length && current->keys[child_index] == key) {
-            child_index += 1;
-        }
-
-        current = current->children[child_index];
-    }
-
-    return current;
-}
-
 void bptree_insert(BPTreeNode *root, uint64_t key, uint64_t data) {
-    int parents_length;
-    BPTreeNode **parents;
-    BPTreeNode *leaf = find_leaf(root, key, &parents_length, &parents);
+    BPTreeNodeArray *parents;
+    BPTreeNode *leaf = find_leaf(root, key, &parents);
 
     // TODO : vérifier si la clé existe dans leaf.
 
     if (has_maximum_keys(leaf)) {
-        insert_full(root, &parents_length, parents, leaf, key, data, NULL);
+        insert_full(root, parents, leaf, key, data, NULL);
     } else {
         insert_non_full(leaf, key, data, NULL);
     }
 
-    free(parents);
+    BPTreeNodeArray_destroy(&parents);
 }
 
 // Deletion

src/bptree.h

@@ -4,15 +4,14 @@
 #include <stdbool.h>
 #include <stdint.h>
 
+#include "Array.h"
+
 typedef struct BPTreeNode {
     int order;
     bool is_leaf;
-    int keys_length;
-    uint64_t *keys;
-    int data_length;
-    uint64_t *data;
-    int children_length;
-    struct BPTreeNode **children;
+    IntegerArray *keys;
+    IntegerArray *data;
+    BPTreeNodeArray *children;
 } BPTreeNode;
 
 BPTreeNode *bptree_init(int order);

src/main.c

@@ -4,20 +4,34 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "Directory.h"
-#include "DirectoryRecord.h"
 #include "bptree.h"
-#include "sorted_array.h"
 
 int main() {
-    BPTreeNode *index = bptree_init(2);
+    BPTreeNode *root = bptree_init(2);
 
-    Directory *directory = Directory_init();
-    Directory_insert(directory, DirectoryRecord_init("0794592180", "Florian", "Burgener", 2000, 10, 03));
-    Directory_insert(directory, DirectoryRecord_init("0799494969", "Daisy", "Luna", 1995, 05, 31));
-    Directory_print(directory);
+    uint64_t input[] = {8, 12, 11, 47, 22, 95, 86, 40, 33, 78, 28, 5, 75, 88, 21, 56, 82, 51, 93, 66, 48, 70, 57, 65, 35, 4, 60, 41, 49, 55, 68, 72, 23, 31, 30, 42, 18, 87, 24, 58};
+    IntegerArray *keys = IntegerArray_init(40);
+    for (int i = 0; i < 40; i++) {
+        IntegerArray_append(keys, input[i]);
+    }
 
-    Directory_destroy(&directory);
-    bptree_destroy(&index);
+    IntegerArray_print(keys);
+
+    for (int i = 0; i < keys->size; i++) {
+        bptree_insert(root, keys->items[i], keys->items[i] * 1000);
+    }
+
+    bptree_print(root, 0);
+
+    for (int i = 0; i < keys->size; i++) {
+        uint64_t data;
+        bool found = bptree_search(root, keys->items[i], &data);
+
+        assert(found == true);
+        assert(data == keys->items[i] * 1000);
+    }
+
+    IntegerArray_destroy(&keys);
+    bptree_destroy(&root);
     return EXIT_SUCCESS;
 }

src/sorted_array.c

-#include "sorted_array.h"
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-int lower_bound(int array_length, uint64_t *array, uint64_t value) {
-    int low = 0;
-    int high = array_length - 1;
-
-    while (low <= high) {
-        int m = (low + high) / 2;
-
-        if (array[m] < value) {
-            low = m + 1;
-        } else if (array[m] > value) {
-            high = m - 1;
-        } else {
-            return m;
-        }
-    }
-
-    return low;
-}
-
-int sorted_array_find_index(int array_length, uint64_t *array, uint64_t value) {
-    int low = 0;
-    int high = array_length - 1;
-
-    while (low <= high) {
-        int m = (low + high) / 2;
-
-        if (array[m] < value) {
-            low = m + 1;
-        } else if (array[m] > value) {
-            high = m - 1;
-        } else {
-            return m;
-        }
-    }
-
-    return -1;
-}
-
-bool sorted_array_search(int array_length, uint64_t *array, uint64_t value, int *index) {
-    int i = sorted_array_find_index(array_length, array, value);
-
-    if (index != NULL) {
-        *index = i;
-    }
-
-    return i != -1;
-}
-
-int sorted_array_insert(int *array_length, uint64_t *array, uint64_t value) {
-    int insertion_index = lower_bound(*array_length, array, value);
-
-    for (int i = *array_length - 1; i >= insertion_index; i--) {
-        array[i + 1] = array[i];
-    }
-
-    array[insertion_index] = value;
-    *array_length += 1;
-    return insertion_index;
-}
-
-void sorted_array_delete(int *array_length, uint64_t *array, uint64_t value) {
-    int index = sorted_array_find_index(*array_length, array, value);
-
-    for (int i = index; i < *array_length; i++) {
-        array[i] = array[i + 1];
-    }
-
-    *array_length -= 1;
-}
-
-void array_insert_at_index(int *array_length, uint64_t *array, int insertion_index, uint64_t value) {
-    for (int i = *array_length - 1; i >= insertion_index; i--) {
-        array[i + 1] = array[i];
-    }
-
-    array[insertion_index] = value;
-    *array_length += 1;
-}
-
-void array_append(int *array_length, uint64_t *array, uint64_t value) {
-    array[*array_length] = value;
-    *array_length += 1;
-}
-
-void array_print(int array_length, uint64_t *array) {
-    printf("[");
-
-    for (int i = 0; i < array_length; i++) {
-        printf("%ld", array[i]);
-
-        if (i < array_length - 1) {
-            printf(", ");
-        }
-    }
-
-    printf("]\n");
-}
-
-void array_insert_at_index_BPTreeNode(int *array_length, BPTreeNode **array, int insertion_index, BPTreeNode *value) {
-    for (int i = *array_length - 1; i >= insertion_index; i--) {
-        array[i + 1] = array[i];
-    }
-
-    array[insertion_index] = value;
-    *array_length += 1;
-}
-
-void array_append_BPTreeNode(int *array_length, BPTreeNode **array, BPTreeNode *value) {
-    array[*array_length] = value;
-    *array_length += 1;
-}
-
-void array_delete_at_index_BPTreeNode(int *array_length, BPTreeNode **array, int deletion_index) {
-    for (int i = deletion_index; i < *array_length; i++) {
-        array[i] = array[i + 1];
-    }
-
-    *array_length -= 1;
-}

src/sorted_array.h

-#ifndef SORTED_ARRAY_H
-#define SORTED_ARRAY_H
-
-#include <stdbool.h>
-#include <stdint.h>
-
-int lower_bound(int array_length, uint64_t *array, uint64_t value);
-
-int sorted_array_find_index(int array_length, uint64_t *array, uint64_t value);
-bool sorted_array_search(int array_length, uint64_t *array, uint64_t value, int *index);
-int sorted_array_insert(int *array_length, uint64_t *array, uint64_t value);
-void sorted_array_delete(int *array_length, uint64_t *array, uint64_t value);
-
-void array_print(int array_length, uint64_t *array);
-void array_insert_at_index(int *array_length, uint64_t *array, int insertion_index, uint64_t value);
-void array_append(int *array_length, uint64_t *array, uint64_t value);
-
-typedef struct BPTreeNode BPTreeNode;
-
-void array_insert_at_index_BPTreeNode(int *array_length, BPTreeNode **array, int insertion_index, BPTreeNode *value);
-void array_append_BPTreeNode(int *array_length, BPTreeNode **array, BPTreeNode *value);
-void array_delete_at_index_BPTreeNode(int *array_length, BPTreeNode **array, int deletion_index);
-
-#endif