diff --git a/_main.c b/_main.c
deleted file mode 100644
index 9f584fe03ae65a54f038697f87e7abcb108fd8c2..0000000000000000000000000000000000000000
--- a/_main.c
+++ /dev/null
@@ -1,32 +0,0 @@
-#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;
-}
diff --git a/src/Array.c b/src/Array.c
index 3c57e189891baa75e7a42403d8ebbde8b7f2bf26..2aae12b5623b209e071e45929e0c4e8dc6561b27 100644
--- a/src/Array.c
+++ b/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--;
diff --git a/src/Array.h b/src/Array.h
index 38f8f81d19d642ded98d1811f7792db33f1b26a2..0ba36fedd47d64c7c37b709cea3084805c6da4ad 100644
--- a/src/Array.h
+++ b/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);
diff --git a/src/Array.o b/src/Array.o
index 98ac59ff25f79787cbd31def792ed68db7f7bdb3..c31e4c7ab6aed7d5c02fffac7260f7ed7ca753d5 100644
Binary files a/src/Array.o and b/src/Array.o differ
diff --git a/src/Directory.o b/src/Directory.o
index 44cdaf0a743353597ff980dca51462dc4e9396e4..77b260a2d3c9b67d23dd49ac88c471b95c0068f6 100644
Binary files a/src/Directory.o and b/src/Directory.o differ
diff --git a/src/DirectoryRecord.o b/src/DirectoryRecord.o
index 86700a2bced8ec1297755924790fa9a47b1b5744..72bea73d54574ea676e178d73fb85693a8304b1d 100644
Binary files a/src/DirectoryRecord.o and b/src/DirectoryRecord.o differ
diff --git a/src/bptree.c b/src/bptree.c
index c9bf2b6cd98eb3788c5a78492578827dbcf01938..5a216d5d6b474ec63f6cea8b191fd4bd9fba2f30 100644
--- a/src/bptree.c
+++ b/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
diff --git a/src/bptree.h b/src/bptree.h
index 05fdd197a9d4008a55ad25cfaf7c08205cc0b856..dcf15be76b524de37acb5956f952dd092d3f7d9f 100644
--- a/src/bptree.h
+++ b/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);
diff --git a/src/bptree.o b/src/bptree.o
index 294a237e01ba5f0ef580c048fb095a908abe53f8..71e13d20252ef1ac8af21af0cd1eb6319323c44e 100644
Binary files a/src/bptree.o and b/src/bptree.o differ
diff --git a/src/main.c b/src/main.c
index ee5ea626811d449c48d13b4c052c6cec4601e108..70b5b9aff0b5af4f20193d014db73e020807bb84 100644
--- a/src/main.c
+++ b/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;
}
diff --git a/src/main.o b/src/main.o
index ca2341be399e9bed35f53bf070ec7056618708e1..b1839b18fd5461fd48e0738adc6f4a6e0635f226 100644
Binary files a/src/main.o and b/src/main.o differ
diff --git a/src/sorted_array.c b/src/sorted_array.c
deleted file mode 100644
index 3e75b04714892a35be6ac86f093eb56637e8c46a..0000000000000000000000000000000000000000
--- a/src/sorted_array.c
+++ /dev/null
@@ -1,126 +0,0 @@
-#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;
-}
diff --git a/src/sorted_array.h b/src/sorted_array.h
deleted file mode 100644
index 02f12fdcd90d6cc122299379ab6d227a1b2db2ed..0000000000000000000000000000000000000000
--- a/src/sorted_array.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#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