Refactor B+ Tree code for improved readability and maintainability

walmir-silva · walmir-silva · commit 25e0a07e039f · 2024-09-24T11:31:16.000-03:00
- Restructured methods in `BPlusTree`, `BPlusTreeInternalNode`, and `BPlusTreeLeafNode` classes to enhance code clarity and organization.
- Removed redundant code and simplified logical conditions for better performance.
- Standardized variable and method naming conventions for consistency throughout the codebase.
- Updated tests in `BPlusTreeTest.php` to reflect the changes made to the classes and ensure functional integrity.
- Prepared the code for future enhancements and extensions in the B+ Tree implementation.
- Added `BPlusTreeSearcherTest.php` (untracked file) for additional testing of search functionality.'
diff --git a/src/Tree/BPlusTree.php b/src/Tree/BPlusTree.php
@@ -47,9 +47,9 @@ public function __construct(private int $order)
         if ($order < 3) {
             throw new \InvalidArgumentException('Order must be at least 3');
         }
-        $this->searcher = new BPlusTreeSearcher();
         $this->order = $order;
-        $this->root = new BPlusTreeLeafNode($order);
+        $this->searcher = new BPlusTreeSearcher();
+        $this->root = null;
     }
 
     public function getRoot(): ?BPlusTreeNode
@@ -64,6 +64,10 @@ public function add(mixed $element): void
 
     public function insert(int $key, mixed $value): void
     {
+        if (null === $this->root) {
+            $this->root = new BPlusTreeLeafNode($this->order);
+        }
+
         $newRoot = $this->root->insert($key, $value);
         if ($newRoot !== $this->root) {
             $this->root = $newRoot;
@@ -83,6 +87,8 @@ public function remove(mixed $element): bool
             --$this->size;
             if ($this->root instanceof BPlusTreeInternalNode && 0 === count($this->root->keys)) {
                 $this->root = $this->root->children[0];
+            } elseif ($this->root instanceof BPlusTreeLeafNode && 0 === count($this->root->keys)) {
+                $this->root = null; // Set root to null when tree is empty
             }
         }
 
@@ -122,6 +128,10 @@ public function get(int $key): mixed
 
     public function set(int $key, mixed $value): void
     {
+        if (null === $this->root) {
+            throw new \OutOfRangeException('Key not found');
+        }
+
         $node = $this->root;
         while ($node instanceof BPlusTreeInternalNode) {
             $index = 0;
@@ -131,6 +141,10 @@ public function set(int $key, mixed $value): void
             $node = $node->children[$index];
         }
 
+        if (null === $node) {
+            throw new \OutOfRangeException('Key not found');
+        }
+
         /** @var BPlusTreeLeafNode $node */
         $index = array_search($key, $node->keys);
         if (false !== $index) {
@@ -196,30 +210,35 @@ public function isBalanced(): bool
             return true;
         }
 
-        return false !== $this->checkBalance($this->root);
+        $leafDepth = null;
+
+        return $this->checkBalance($this->root, 0, $leafDepth);
     }
 
-    private function checkBalance(?BPlusTreeNode $node): int
+    private function checkBalance(?BPlusTreeNode $node, int $currentDepth = 0, ?int &$leafDepth = null): bool
     {
         if (null === $node) {
-            return 0;
+            return true;
         }
 
         if ($node instanceof BPlusTreeLeafNode) {
-            return 1;
+            if (null === $leafDepth) {
+                $leafDepth = $currentDepth;
+            } elseif ($currentDepth !== $leafDepth) {
+                return false;
+            }
+
+            return true;
         }
 
         /** @var BPlusTreeInternalNode $node */
-        $height = $this->checkBalance($node->children[0]);
-
-        for ($i = 1; $i < count($node->children); ++$i) {
-            $childHeight = $this->checkBalance($node->children[$i]);
-            if ($childHeight !== $height) {
-                throw new \RuntimeException('B+ Tree is not balanced');
+        foreach ($node->children as $child) {
+            if (! $this->checkBalance($child, $currentDepth + 1, $leafDepth)) {
+                return false;
             }
         }
 
-        return $height + 1;
+        return true;
     }
 
     public function sort(): void
diff --git a/src/Tree/BPlusTreeNode/BPlusTreeInternalNode.php b/src/Tree/BPlusTreeNode/BPlusTreeInternalNode.php
@@ -51,30 +51,27 @@ private function findIndex(int $key): int
 
     private function split(): BPlusTreeInternalNode
     {
-        $order = $this->order;
-        $middleKeyIndex = (int) (($order - 1) / 2);
+        $numKeys = count($this->keys);
+        $middleKeyIndex = intdiv($numKeys, 2);
         $middleKey = $this->keys[$middleKeyIndex];
 
-        // Create left and right nodes
-        $leftNode = new BPlusTreeInternalNode($order);
-        $rightNode = new BPlusTreeInternalNode($order);
+        $leftNode = new BPlusTreeInternalNode($this->order);
+        $rightNode = new BPlusTreeInternalNode($this->order);
 
-        // Left node keys and children
         $leftNode->keys = array_slice($this->keys, 0, $middleKeyIndex);
         $leftNode->children = array_slice($this->children, 0, $middleKeyIndex + 1);
 
-        // Right node keys and children
         $rightNode->keys = array_slice($this->keys, $middleKeyIndex + 1);
         $rightNode->children = array_slice($this->children, $middleKeyIndex + 1);
 
-        // Create a new parent node and promote the middle key
-        $parent = new BPlusTreeInternalNode($order);
+        $parent = new BPlusTreeInternalNode($this->order);
         $parent->keys = [$middleKey];
         $parent->children = [$leftNode, $rightNode];
 
         return $parent;
     }
 
+
     public function search(mixed $key): mixed
     {
         $index = $this->findInsertionIndex($key);
diff --git a/src/Tree/BPlusTreeNode/BPlusTreeLeafNode.php b/src/Tree/BPlusTreeNode/BPlusTreeLeafNode.php
@@ -41,9 +41,9 @@ private function findIndex(int $key): int
 
     private function split(): BPlusTreeInternalNode
     {
-        $order = $this->order;
-        $middleIndex = (int) ($order / 2);
-        $newNode = new BPlusTreeLeafNode($order);
+        $numKeys = count($this->keys);
+        $middleIndex = intdiv($numKeys, 2);
+        $newNode = new BPlusTreeLeafNode($this->order);
 
         $newNode->keys = array_slice($this->keys, $middleIndex);
         $newNode->values = array_slice($this->values, $middleIndex);
@@ -54,7 +54,7 @@ private function split(): BPlusTreeInternalNode
         $newNode->next = $this->next;
         $this->next = $newNode;
 
-        $parent = new BPlusTreeInternalNode($order);
+        $parent = new BPlusTreeInternalNode($this->order);
         $parent->keys = [$newNode->keys[0]];
         $parent->children = [$this, $newNode];
 
diff --git a/tests/Tree/BPlusTreeSearcherTest.php b/tests/Tree/BPlusTreeSearcherTest.php
@@ -0,0 +1,221 @@
+<?php
+
+declare(strict_types=1);
+
+use KaririCode\DataStructure\Tree\BPlusTree;
+use KaririCode\DataStructure\Tree\BPlusTreeNode\BPlusTreeLeafNode;
+use KaririCode\DataStructure\Tree\BPlusTreeSearcher;
+use PHPUnit\Framework\TestCase;
+
+final class BPlusTreeSearcherTest extends TestCase
+{
+    private BPlusTree $tree;
+    private BPlusTreeSearcher $searcher;
+
+    protected function setUp(): void
+    {
+        $this->tree = new BPlusTree(4); // Using order 4 for the tree
+        $this->searcher = new BPlusTreeSearcher();
+    }
+
+    public function testFindByKey(): void
+    {
+        // Insert elements into the tree
+        $this->tree->insert(10, 'Value10');
+        $this->tree->insert(20, 'Value20');
+        $this->tree->insert(30, 'Value30');
+        $this->tree->insert(40, 'Value40');
+
+        // Test finding existing keys
+        $result = $this->searcher->find($this->tree, 20);
+        $this->assertEquals('Value20', $result);
+
+        $result = $this->searcher->find($this->tree, 40);
+        $this->assertEquals('Value40', $result);
+
+        // Test finding a non-existing key
+        $result = $this->searcher->find($this->tree, 50);
+        $this->assertNull($result);
+    }
+
+    public function testFindByValue(): void
+    {
+        // Insert elements into the tree
+        $this->tree->insert(5, 'Value5');
+        $this->tree->insert(15, 'Value15');
+        $this->tree->insert(25, 'Value25');
+        $this->tree->insert(35, 'Value35');
+
+        // Test finding existing values
+        $result = $this->searcher->find($this->tree, 'Value15');
+        $this->assertEquals(15, $result);
+
+        $result = $this->searcher->find($this->tree, 'Value35');
+        $this->assertEquals(35, $result);
+
+        // Test finding a non-existing value
+        $result = $this->searcher->find($this->tree, 'Value50');
+        $this->assertNull($result);
+    }
+
+    public function testRangeSearch(): void
+    {
+        // Insert elements into the tree
+        for ($i = 1; $i <= 20; ++$i) {
+            $this->tree->insert($i * 5, 'Value' . ($i * 5));
+        }
+
+        // Perform a range search
+        $result = $this->searcher->rangeSearch($this->tree, 30, 70);
+
+        // Expected values are from 30 to 70 (inclusive)
+        $expected = ['Value30', 'Value35', 'Value40', 'Value45', 'Value50', 'Value55', 'Value60', 'Value65', 'Value70'];
+
+        $this->assertEquals($expected, $result);
+
+        // Test an empty range
+        $result = $this->searcher->rangeSearch($this->tree, 105, 110);
+        $this->assertEmpty($result);
+    }
+
+    public function testSearchInLeafNode(): void
+    {
+        // Directly test the private method searchInLeafNode using reflection
+        $leafNode = new BPlusTreeLeafNode(4);
+        $leafNode->keys = [10, 20, 30];
+        $leafNode->values = ['Value10', 'Value20', 'Value30'];
+
+        // Use reflection to access the private method
+        $reflection = new ReflectionClass(BPlusTreeSearcher::class);
+        $method = $reflection->getMethod('searchInLeafNode');
+        $method->setAccessible(true);
+
+        // Test finding an existing value
+        $index = $method->invokeArgs($this->searcher, [$leafNode, 'Value20']);
+        $this->assertEquals(20, $index);
+
+        // Test finding a non-existing value
+        $index = $method->invokeArgs($this->searcher, [$leafNode, 'Value50']);
+        $this->assertNull($index);
+    }
+
+    public function testCompareValues(): void
+    {
+        // Directly test the private method compareValues using reflection
+        $reflection = new ReflectionClass(BPlusTreeSearcher::class);
+        $method = $reflection->getMethod('compareValues');
+        $method->setAccessible(true);
+
+        // Test comparison of scalars
+        $result = $method->invokeArgs($this->searcher, [10, 10]);
+        $this->assertTrue($result);
+
+        $result = $method->invokeArgs($this->searcher, [10, 20]);
+        $this->assertFalse($result);
+
+        // Test comparison of objects
+        $obj1 = (object) ['a' => 1];
+        $obj2 = (object) ['a' => 1];
+        $obj3 = (object) ['a' => 2];
+
+        $result = $method->invokeArgs($this->searcher, [$obj1, $obj2]);
+        $this->assertTrue($result);
+
+        $result = $method->invokeArgs($this->searcher, [$obj1, $obj3]);
+        $this->assertFalse($result);
+    }
+
+    public function testFindFirstLeafNode(): void
+    {
+        // Create a tree with multiple levels
+        for ($i = 1; $i <= 50; ++$i) {
+            $this->tree->insert($i, "Value$i");
+        }
+
+        // Use reflection to access the private method
+        $reflection = new ReflectionClass(BPlusTreeSearcher::class);
+        $method = $reflection->getMethod('findFirstLeafNode');
+        $method->setAccessible(true);
+
+        $firstLeaf = $method->invokeArgs($this->searcher, [$this->tree->getRoot()]);
+        $this->assertInstanceOf(BPlusTreeLeafNode::class, $firstLeaf);
+
+        // The first leaf node should contain the smallest keys
+        $this->assertContains(1, $firstLeaf->keys);
+    }
+
+    public function testSearchByValueWithNonExistingValue(): void
+    {
+        // Insert elements into the tree
+        $this->tree->insert(100, 'Value100');
+        $this->tree->insert(200, 'Value200');
+
+        // Test searching for a non-existing value
+        $result = $this->searcher->find($this->tree, 'NonExistingValue');
+        $this->assertNull($result);
+    }
+
+    public function testSearchWithEmptyTree(): void
+    {
+        // Create an empty tree
+        $emptyTree = new BPlusTree(4);
+
+        // Test searching in an empty tree
+        $result = $this->searcher->find($emptyTree, 10);
+        $this->assertNull($result);
+
+        $result = $this->searcher->rangeSearch($emptyTree, 10, 20);
+        $this->assertEmpty($result);
+    }
+
+    public function testFindWithNullValue(): void
+    {
+        // Insert elements with null values
+        $this->tree->insert(1, null);
+        $this->tree->insert(2, 'Value2');
+
+        // Test finding a key with a null value
+        $result = $this->searcher->find($this->tree, null);
+        $this->assertEquals(1, $result);
+    }
+
+    public function testSearchWithDuplicateValues(): void
+    {
+        // Insert elements with duplicate values
+        $this->tree->insert(1, 'DuplicateValue');
+        $this->tree->insert(2, 'DuplicateValue');
+        $this->tree->insert(3, 'UniqueValue');
+
+        // Test finding by value (should return the first key that matches)
+        $result = $this->searcher->find($this->tree, 'DuplicateValue');
+        $this->assertEquals(1, $result);
+
+        // Test that the search continues correctly after duplicates
+        $result = $this->searcher->find($this->tree, 'UniqueValue');
+        $this->assertEquals(3, $result);
+    }
+
+    public function testRangeSearchWithSingleElementRange(): void
+    {
+        // Insert elements into the tree
+        $this->tree->insert(10, 'Value10');
+        $this->tree->insert(20, 'Value20');
+
+        // Perform a range search where start and end are the same
+        $result = $this->searcher->rangeSearch($this->tree, 20, 20);
+        $this->assertEquals(['Value20'], $result);
+    }
+
+    public function testFindWithEmptyTree(): void
+    {
+        // Create an empty tree
+        $emptyTree = new BPlusTree(4);
+
+        // Ensure the root is null
+        $this->assertNull($emptyTree->getRoot());
+
+        // Test finding an element in an empty tree
+        $result = $this->searcher->find($emptyTree, 10);
+        $this->assertNull($result);
+    }
+}
diff --git a/tests/Tree/BPlusTreeTest.php b/tests/Tree/BPlusTreeTest.php
