src/BPTree.c

@@ -322,29 +322,29 @@ static bool is_sibling_left_side(BPTreeNode *parent, BPTreeNode *node, BPTreeNod
 static void merge(BPTreeNode *parent, BPTreeNode *left_node, BPTreeNode *right_node) {
     int index_in_children = BPTreeNodeArray_search(parent->children, left_node);
 
-    if (!right_node->is_leaf) {
-        IntegerArray_insert_at_index(right_node->keys, 0, parent->keys->items[index_in_children]);
+    if (!left_node->is_leaf) {
+        IntegerArray_append(left_node->keys, parent->keys->items[index_in_children]);
     }
 
     // Merge the keys.
-    for (int i = left_node->keys->size - 1; i >= 0; i--) {
-        IntegerArray_insert_at_index(right_node->keys, 0, left_node->keys->items[i]);
+    for (int i = 0; i < right_node->keys->size; i++) {
+        IntegerArray_append(left_node->keys, right_node->keys->items[i]);
     }
 
     // Merge the data.
-    for (int i = left_node->data->size - 1; i >= 0; i--) {
-        IntegerArray_insert_at_index(right_node->data, 0, left_node->data->items[i]);
+    for (int i = 0; i < right_node->data->size; i++) {
+        IntegerArray_append(left_node->data, right_node->data->items[i]);
     }
 
     // Merge the children.
-    for (int i = left_node->children->size - 1; i >= 0; i--) {
-        BPTreeNodeArray_insert_at_index(right_node->children, 0, left_node->children->items[i]);
+    for (int i = 0; i < right_node->children->size; i++) {
+        BPTreeNodeArray_append(left_node->children, right_node->children->items[i]);
     }
 
     IntegerArray_delete_at_index(parent->keys, index_in_children);
-    BPTreeNodeArray_delete_at_index(parent->children, index_in_children);
-
-    BPTreeNode_destroy(&left_node);
+    BPTreeNodeArray_delete_at_index(parent->children, index_in_children + 1);
+    left_node->next = right_node->next;
+    BPTreeNode_destroy(&right_node);
 }
 
 static void steal_leaf(BPTreeNode *parent, BPTreeNode *node, BPTreeNode *sibling) {

src/tests/BPTreeTests.c

@@ -314,7 +314,7 @@ static void test_BPTree_insert_should_comply_with_BPTree_rules_using_BPTree_of_g
 
             for (int i = 0; i < keys->size; i++) {
                 BPTree_insert(root, keys->items[i], transform_key_to_data(keys->items[i]));
-                // After each insertion, we check that the B+ tree is compliant with the B+ Tree rules.
+                // After each insertion, is checked that the B+ tree conforms to the rules of the B+ tree.
                 TEST_ASSERT(check_BPTree_compliance(root));
             }
 
@@ -376,7 +376,7 @@ void test_BPTree_delete_should_comply_with_BPTree_rules_using_BPTree_of_given_or
             while (keys->size > 0) {
                 int index = rand() % keys->size;
                 BPTree_delete(root, keys->items[index]);
-                // After each deletion, we check that the B+ tree conforms to the B+ Tree rules.
+                // After each deletion, is checked that the B+ tree conforms to the rules of the B+ tree.
                 TEST_ASSERT(check_BPTree_compliance(root));
                 IntegerArray_delete_at_index(keys, index);
             }
@@ -437,7 +437,7 @@ void test_BPTree_search_should_find_the_keys_that_exist_in_the_BPTree_using_BPTr
             uint64_t data;
             bool is_found = BPTree_search(root, keys->items[i], &data);
 
-            // After each search, we check that the key has been found and that the relationship between it and the data is correct.
+            // After each search, is checked that the key has been found and that the relationship between it and the data is correct.
             TEST_ASSERT(is_found);
             TEST_ASSERT_EQUAL_UINT64(transform_key_to_data(keys->items[i]), data);
         }