Skip to content

Commit a547e33

Browse files
walmir-silvawalmir-silva
committed
Fix B+ Tree implementation and tests to address node splitting, key promotion, and key-based access
- **Adjusted `BPlusTreeInternalNode::insert()` Method:** - Corrected the insertion logic to maintain proper alignment between `keys` and `children` arrays. - Ensured that when a child node splits, the promoted key is inserted into the current node's `keys`, and the new child node is correctly placed in the `children` array. - **Modified `split()` Methods in Nodes:** - Updated `BPlusTreeInternalNode::split()` to correctly calculate the middle index and properly split `keys` and `children` arrays. - Promoted the appropriate key to the parent node during splits. - Ensured that each internal node maintains the B+ Tree properties after splitting. - Adjusted `BPlusTreeLeafNode::split()` to handle small orders and maintain the linked list of leaf nodes. - **Updated Tree Size Management:** - Incremented the `size` property in the `BPlusTree` class during insertions to accurately reflect the number of elements. - Fixed issues where the `size` was not updated, causing `OutOfRangeException` errors. - **Revised `set` and `get` Methods:** - Changed `set` and `get` methods to operate on keys rather than indices, aligning with the key-based nature of B+ Trees. - Updated `set` to traverse the tree and update the value associated with a given key. - Modified `get` to retrieve the value based on the key, throwing an exception if the key is not found. - **Fixed Test Cases:** - Adjusted `testVisualTreeStructure` to insert enough keys to cause node splitting, ensuring both internal and leaf nodes are present. - Updated `testGetOrder` by correcting the `order` property assignment in the `BPlusTree` class, matching expected values in tests. - Renamed and modified `testSetAndGetByIndex` to `testSetAndGetByKey`, reflecting the changes in method functionality. - **Improved Code Consistency and Documentation:** - Removed redundant property declarations and assignments in the `BPlusTree` constructor. - Ensured consistent use of the `order` property throughout the class. - Added comments and documentation to clarify method purposes and enhance readability. - Ensured alignment between method implementations and their intended use cases. **Summary:** These corrections address critical issues in the B+ Tree implementation related to node splitting, key promotion, and data access by keys. By refining the logic in node insertion and splitting methods, the tree now correctly maintains its balanced structure and properties, even with small orders. The `size` property accurately tracks the number of elements, preventing out-of-range errors. The `set` and `get` methods now intuitively operate on keys, improving usability. Tests have been updated to reflect these changes, ensuring the reliability and correctness of the implementation.
1 parent 620f7af commit a547e33

14 files changed

+2831
-318
lines changed

‎.gitignore

+2
Original file line numberDiff line numberDiff line change
@@ -59,3 +59,5 @@ temp/
5959
tmp/
6060
.vscode/launch.json
6161
.vscode/extensions.json
62+
lista_de_arquivos.txt
63+
tests/lista_de_arquivos.php

‎src/Tree/BPlusTree.php

+127-120
Original file line numberDiff line numberDiff line change
@@ -10,53 +10,78 @@
1010
use KaririCode\DataStructure\Tree\BPlusTreeNode\BPlusTreeLeafNode;
1111
use KaririCode\DataStructure\Tree\BPlusTreeNode\BPlusTreeNode;
1212

13+
/**
14+
* BPlusTree is an implementation of a B+ Tree data structure.
15+
*
16+
* The B+ Tree is a self-balancing tree data structure that maintains sorted data
17+
* and allows for efficient insertion, deletion, and search operations. It is commonly
18+
* used in databases and file systems.
19+
*
20+
* ### Complexity Analysis:
21+
* - **Time Complexity**:
22+
* - Insertion: O(log n)
23+
* - Deletion: O(log n)
24+
* - Search: O(log n)
25+
* - Range Search: O(log n + k), where k is the number of elements in the range
26+
* - **Space Complexity**:
27+
* - Space: O(n)
28+
*
29+
* The B+ Tree provides better space utilization and supports range queries efficiently.
30+
* It is optimized for systems that read and write large blocks of data.
31+
*
32+
* @category Trees
33+
*
34+
* @author Walmir Silva <[email protected]>
35+
* @license MIT
36+
*
37+
* @see https://kariricode.org/
38+
*/
1339
class BPlusTree implements BPlusTreeCollection
1440
{
15-
private int $order;
16-
private ?BPlusTreeNode $root;
41+
private ?BPlusTreeNode $root = null;
42+
private BPlusTreeSearcher $searcher;
1743
private int $size = 0;
1844

19-
public function __construct(int $order)
45+
public function __construct(private int $order)
2046
{
2147
if ($order < 3) {
22-
throw new \InvalidArgumentException("Order must be at least 3");
48+
throw new \InvalidArgumentException('Order must be at least 3');
2349
}
50+
$this->searcher = new BPlusTreeSearcher();
2451
$this->order = $order;
25-
$this->root = null;
52+
$this->root = new BPlusTreeLeafNode($order);
53+
}
54+
55+
public function getRoot(): ?BPlusTreeNode
56+
{
57+
return $this->root;
2658
}
2759

2860
public function add(mixed $element): void
2961
{
3062
$this->insert($element, $element);
3163
}
3264

33-
public function insert(int $index, mixed $value): void
65+
public function insert(int $key, mixed $value): void
3466
{
35-
if ($this->root === null) {
36-
$this->root = new BPlusTreeLeafNode($this->order);
37-
}
38-
39-
$this->root = $this->root->insert($index, $value);
40-
41-
if ($this->root->isFull()) {
42-
$newRoot = new BPlusTreeInternalNode($this->order);
43-
$newRoot->children[] = $this->root;
44-
$this->root = $newRoot->split();
67+
$newRoot = $this->root->insert($key, $value);
68+
if ($newRoot !== $this->root) {
69+
$this->root = $newRoot;
4570
}
4671

47-
$this->size++;
72+
++$this->size;
4873
}
4974

5075
public function remove(mixed $element): bool
5176
{
52-
if ($this->root === null) {
77+
if (null === $this->root) {
5378
return false;
5479
}
5580

5681
$result = $this->root->remove($element);
5782
if ($result) {
58-
$this->size--;
59-
if ($this->root instanceof BPlusTreeInternalNode && count($this->root->keys) === 0) {
83+
--$this->size;
84+
if ($this->root instanceof BPlusTreeInternalNode && 0 === count($this->root->keys)) {
6085
$this->root = $this->root->children[0];
6186
}
6287
}
@@ -70,80 +95,49 @@ public function clear(): void
7095
$this->size = 0;
7196
}
7297

73-
public function contains(mixed $element): bool
98+
public function find(mixed $element): mixed
7499
{
75-
return $this->find($element) !== null;
100+
return $this->searcher->find($this, $element);
76101
}
77102

78-
public function find(mixed $element): mixed
103+
public function contains(mixed $element): bool
79104
{
80-
if ($this->root === null) {
81-
return null;
82-
}
83-
if (is_int($element)) {
84-
return $this->root->search($element);
85-
} else {
86-
return $this->searchByValue($element);
87-
}
105+
return null !== $this->find($element);
88106
}
89107

90-
private function searchByValue(mixed $value): ?int
108+
public function rangeSearch(mixed $start, mixed $end): array
91109
{
92-
$current = $this->getLeftmostLeaf();
93-
while ($current !== null) {
94-
foreach ($current->values as $index => $nodeValue) {
95-
if ($nodeValue === $value) {
96-
return $current->keys[$index];
97-
}
98-
}
99-
$current = $current->next;
100-
}
101-
return null;
110+
return $this->searcher->rangeSearch($this, $start, $end);
102111
}
103112

104-
public function get(int $index): mixed
113+
public function get(int $key): mixed
105114
{
106-
if ($index < 0 || $index >= $this->size) {
107-
throw new \OutOfRangeException("Index out of range");
108-
}
109-
110-
$current = $this->root;
111-
while ($current instanceof BPlusTreeInternalNode) {
112-
$current = $current->children[0];
113-
}
114-
115-
/** @var BPlusTreeLeafNode $current */
116-
for ($i = 0; $i < $index; $i++) {
117-
$current = $current->next;
118-
if ($current === null) {
119-
throw new \OutOfRangeException("Index out of range");
120-
}
115+
$value = $this->find($key);
116+
if (null !== $value) {
117+
return $value;
118+
} else {
119+
throw new \OutOfRangeException('Key not found');
121120
}
122-
123-
return $current->values[0];
124121
}
125122

126-
public function set(int $index, mixed $element): void
123+
public function set(int $key, mixed $value): void
127124
{
128-
if ($index < 0 || $index >= $this->size) {
129-
throw new \OutOfRangeException("Index out of range");
130-
}
131-
132-
$current = $this->getLeftmostLeaf();
133-
$currentIndex = 0;
134-
135-
while ($current !== null) {
136-
for ($i = 0; $i < count($current->keys); $i++) {
137-
if ($current->keys[$i] == $index) {
138-
$current->values[$i] = $element;
139-
return;
140-
}
141-
$currentIndex++;
125+
$node = $this->root;
126+
while ($node instanceof BPlusTreeInternalNode) {
127+
$index = 0;
128+
while ($index < count($node->keys) && $key >= $node->keys[$index]) {
129+
++$index;
142130
}
143-
$current = $current->next;
131+
$node = $node->children[$index];
144132
}
145133

146-
throw new \OutOfRangeException("Index not found");
134+
/** @var BPlusTreeLeafNode $node */
135+
$index = array_search($key, $node->keys);
136+
if (false !== $index) {
137+
$node->values[$index] = $value;
138+
} else {
139+
throw new \OutOfRangeException('Key not found');
140+
}
147141
}
148142

149143
public function size(): int
@@ -155,10 +149,11 @@ public function getItems(): array
155149
{
156150
$items = [];
157151
$current = $this->getLeftmostLeaf();
158-
while ($current !== null) {
152+
while (null !== $current) {
159153
$items = array_merge($items, $current->values);
160154
$current = $current->next;
161155
}
156+
162157
return $items;
163158
}
164159

@@ -174,49 +169,18 @@ public function getOrder(): int
174169
return $this->order;
175170
}
176171

177-
// In BPlusTree.php
178-
179-
public function rangeSearch(mixed $start, mixed $end): array
180-
{
181-
$result = [];
182-
$current = $this->root;
183-
184-
// Find the leaf node where the range starts
185-
while ($current instanceof BPlusTreeInternalNode) {
186-
$i = 0;
187-
while ($i < count($current->keys) && $start > $current->keys[$i]) {
188-
$i++;
189-
}
190-
$current = $current->children[$i];
191-
}
192-
193-
// Collect all values in the range
194-
/** @var BPlusTreeLeafNode $current */
195-
while ($current !== null) {
196-
foreach ($current->values as $key => $value) {
197-
if ($current->keys[$key] >= $start && $current->keys[$key] <= $end) {
198-
$result[] = $value;
199-
}
200-
if ($current->keys[$key] > $end) {
201-
return $result;
202-
}
203-
}
204-
$current = $current->next;
205-
}
206-
207-
return $result;
208-
}
209-
210172
public function getMinimum(): mixed
211173
{
212174
$leftmostLeaf = $this->getLeftmostLeaf();
213-
return $leftmostLeaf !== null ? $leftmostLeaf->values[0] : null;
175+
176+
return null !== $leftmostLeaf ? $leftmostLeaf->values[0] : null;
214177
}
215178

216179
public function getMaximum(): mixed
217180
{
218181
$rightmostLeaf = $this->getRightmostLeaf();
219-
return $rightmostLeaf !== null ? $rightmostLeaf->values[count($rightmostLeaf->values) - 1] : null;
182+
183+
return null !== $rightmostLeaf ? $rightmostLeaf->values[count($rightmostLeaf->values) - 1] : null;
220184
}
221185

222186
public function balance(): void
@@ -226,24 +190,32 @@ public function balance(): void
226190
$this->checkBalance($this->root);
227191
}
228192

193+
public function isBalanced(): bool
194+
{
195+
if (null === $this->root) {
196+
return true;
197+
}
198+
199+
return false !== $this->checkBalance($this->root);
200+
}
201+
229202
private function checkBalance(?BPlusTreeNode $node): int
230203
{
231-
if ($node === null) {
204+
if (null === $node) {
232205
return 0;
233206
}
234207

235208
if ($node instanceof BPlusTreeLeafNode) {
236209
return 1;
237210
}
238211

239-
240212
/** @var BPlusTreeInternalNode $node */
241213
$height = $this->checkBalance($node->children[0]);
242214

243-
for ($i = 1; $i < count($node->children); $i++) {
215+
for ($i = 1; $i < count($node->children); ++$i) {
244216
$childHeight = $this->checkBalance($node->children[$i]);
245217
if ($childHeight !== $height) {
246-
throw new \RuntimeException("B+ Tree is not balanced");
218+
throw new \RuntimeException('B+ Tree is not balanced');
247219
}
248220
}
249221

@@ -262,10 +234,10 @@ private function checkSorted(): void
262234
$current = $this->getLeftmostLeaf();
263235
$prev = null;
264236

265-
while ($current !== null) {
237+
while (null !== $current) {
266238
foreach ($current->values as $value) {
267-
if ($prev !== null && $value < $prev) {
268-
throw new \RuntimeException("B+ Tree is not sorted");
239+
if (null !== $prev && $value < $prev) {
240+
throw new \RuntimeException('B+ Tree is not sorted');
269241
}
270242
$prev = $value;
271243
}
@@ -279,6 +251,7 @@ private function getLeftmostLeaf(): ?BPlusTreeLeafNode
279251
while ($current instanceof BPlusTreeInternalNode) {
280252
$current = $current->children[0];
281253
}
254+
282255
return $current;
283256
}
284257

@@ -288,6 +261,40 @@ private function getRightmostLeaf(): ?BPlusTreeLeafNode
288261
while ($current instanceof BPlusTreeInternalNode) {
289262
$current = $current->children[count($current->children) - 1];
290263
}
264+
291265
return $current;
292266
}
267+
268+
public function visualTreeStructure(): string
269+
{
270+
if (null === $this->root) {
271+
return 'Empty tree';
272+
}
273+
274+
return $this->visualizeNode($this->root);
275+
}
276+
277+
private function visualizeNode(BPlusTreeNode $node, int $depth = 0): string
278+
{
279+
$indent = str_repeat(' ', $depth);
280+
$output = '';
281+
282+
if ($node instanceof BPlusTreeInternalNode) {
283+
$output .= $indent . "Internal Node:\n";
284+
$output .= $indent . ' Keys: ' . implode(', ', $node->keys) . "\n";
285+
foreach ($node->children as $index => $child) {
286+
$output .= $indent . ' Child ' . ($index + 1) . ":\n";
287+
$output .= $this->visualizeNode($child, $depth + 2);
288+
}
289+
} elseif ($node instanceof BPlusTreeLeafNode) {
290+
$output .= $indent . "Leaf Node:\n";
291+
$output .= $indent . ' Keys: ' . implode(', ', $node->keys) . "\n";
292+
$output .= $indent . ' Values: ' . implode(', ', $node->values) . "\n";
293+
if ($node->next) {
294+
$output .= $indent . ' Next Leaf -> [' . implode(', ', $node->next->keys) . "]\n";
295+
}
296+
}
297+
298+
return $output;
299+
}
293300
}

0 commit comments

Comments
 (0)