basic btree works
Some checks failed
Rust CI / Test Suite (push) Failing after 2s
Rust CI / Clippy (push) Failing after 4s

This commit is contained in:
Christoph J. Scherr 2025-06-04 21:30:27 +02:00
parent 9f09799413
commit d63222a6ef
Signed by: PlexSheep
GPG key ID: 9EB784BB202BB7BB

View file

@ -1,9 +1,20 @@
use std::mem;
use crate::vec::Vec;
pub const DEFAULT_DEGREE: usize = 1;
#[derive(Clone, Debug)]
pub struct BTree<T> {
pub struct BTree<T: Ord + Clone> {
root: Node<T>,
properties: BTreeProperties,
}
#[derive(Clone, Debug, Copy)]
pub struct BTreeProperties {
degree: usize,
max_keys: usize,
mid_key_index: usize,
}
#[derive(Clone, Debug)]
@ -12,6 +23,63 @@ struct Node<T> {
children: Vec<Node<T>>,
}
impl BTreeProperties {
fn new(degree: usize) -> Self {
Self {
degree,
max_keys: degree - 1,
mid_key_index: (degree - 1) / 2,
}
}
fn split_child<T: Ord + Clone>(&self, parent: &mut Node<T>, child_index: usize) {
let child = &mut parent.children[child_index];
let middle_key: T = child.keys[self.mid_key_index].clone();
let right_keys = match child.keys.split_off(self.mid_key_index).split_first() {
Some((_first, _others)) => {
// We don't need _first, as it will move to parent node.
_others.into()
}
None => Vec::<T>::with_capacity(self.max_keys),
};
let right_children = if !child.is_leaf() {
Some(child.children.split_off(self.mid_key_index + 1))
} else {
None
};
let new_child_node: Node<T> = Node::new(self.degree, Some(right_keys), right_children);
parent.keys.insert(child_index, middle_key);
parent.children.insert(child_index + 1, new_child_node);
}
fn is_maxed_out<T: Ord>(&self, node: &Node<T>) -> bool {
node.keys.len() == self.max_keys
}
fn insert_non_full<T: Ord + Clone>(&mut self, node: &mut Node<T>, key: T) {
let mut index: isize = isize::try_from(node.keys.len()).ok().unwrap() - 1;
while index >= 0 && node.keys[index as usize] >= key {
index -= 1;
}
let mut u_index: usize = usize::try_from(index + 1).ok().unwrap();
if node.is_leaf() {
// Just insert it, as we know this method will be called only when node is not full
node.keys.insert(u_index, key);
} else {
if self.is_maxed_out(&node.children[u_index]) {
self.split_child(node, u_index);
if node.keys[u_index] < key {
u_index += 1;
}
}
self.insert_non_full(&mut node.children[u_index], key);
}
}
}
impl<T> Node<T>
where
T: Ord,
@ -34,47 +102,63 @@ where
}
}
impl<T: Ord> BTree<T> {
impl<T: Ord + Clone> BTree<T> {
pub fn new(branch_factor: usize) -> Self {
let degree = 2 * branch_factor;
Self {
root: Node::new(degree, None, None),
degree,
properties: BTreeProperties::new(degree),
}
}
pub fn clear(&mut self) {
self.root = Node::new(self.degree, None, None);
self.root = Node::new(self.properties.degree, None, None);
}
fn rebalance() {
todo!()
pub fn insert(&mut self, key: T) {
if self.properties.is_maxed_out(&self.root) {
// Create an empty root and split the old root...
let mut new_root = Node::new(self.properties.degree, None, None);
mem::swap(&mut new_root, &mut self.root);
self.root.children.insert(0, new_root);
self.properties.split_child(&mut self.root, 0);
}
self.properties.insert_non_full(&mut self.root, key)
}
pub fn insert(&mut self, value: T) -> Option<T> {
todo!()
}
pub fn has(&self, value: T) -> bool {
todo!()
#[must_use]
pub fn has(&self, key: T) -> bool {
let mut current_node = &self.root;
loop {
match current_node.keys.binary_search(&key) {
Ok(_) => return true,
Err(idx) => {
if current_node.is_leaf() {
return false;
}
current_node = &current_node.children[idx];
}
}
}
}
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test_create() {
let _tree = BTree::<u32>::new();
let _tree = BTree::<u32>::new(DEFAULT_DEGREE);
}
#[test]
fn test_insert() {
let mut tree = BTree::<u32>::new();
let mut tree = BTree::<u32>::new(DEFAULT_DEGREE);
let data = &[19, 125, 25, 16, 2, 73, 384, 435, 12924, 42, 125251, 2548];
for d in data {
assert!(tree.insert(*d).is_none())
tree.insert(*d)
}
for d in data {