2023-01-22 09:42:08 +01:00
|
|
|
#include "vieter_tree_node.h"
|
|
|
|
#include "vieter_tree_balancing.h"
|
2023-01-19 22:23:19 +01:00
|
|
|
|
2023-01-29 20:57:08 +01:00
|
|
|
#include <string.h>
|
|
|
|
|
2023-01-19 22:23:19 +01:00
|
|
|
vieter_tree_node *vieter_tree_node_init() {
|
|
|
|
return calloc(1, sizeof(vieter_tree_node));
|
|
|
|
}
|
|
|
|
|
2023-01-20 11:07:33 +01:00
|
|
|
void vieter_tree_node_free(vieter_tree_node *node) { free(node); }
|
|
|
|
|
2023-01-19 22:45:22 +01:00
|
|
|
void vieter_tree_node_add_child(vieter_tree_node *parent, uint64_t key,
|
|
|
|
vieter_tree_node *child) {
|
|
|
|
if (parent == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-01-29 20:57:08 +01:00
|
|
|
bool side = key > parent->key;
|
|
|
|
parent->children[side] = child;
|
2023-01-19 22:45:22 +01:00
|
|
|
|
|
|
|
if (child != NULL) {
|
|
|
|
child->parent = parent;
|
2023-01-29 20:57:08 +01:00
|
|
|
vieter_tree_node_set(child, vieter_tree_node_right, side);
|
2023-01-19 22:45:22 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-29 21:08:17 +01:00
|
|
|
void vieter_tree_node_set_children(vieter_tree_node *parent,
|
|
|
|
vieter_tree_node **children) {
|
|
|
|
memcpy(parent->children, children, 2 * sizeof(vieter_tree_node *));
|
|
|
|
|
|
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
|
|
if (parent->children[i] != NULL) {
|
|
|
|
parent->children[i]->parent = parent;
|
|
|
|
vieter_tree_node_set(parent->children[i], vieter_tree_node_right, i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-29 21:34:44 +01:00
|
|
|
void vieter_tree_node_set_child(vieter_tree_node *parent,
|
|
|
|
vieter_tree_node *child, bool right) {
|
|
|
|
parent->children[right] = child;
|
|
|
|
|
|
|
|
if (child != NULL) {
|
|
|
|
child->parent = parent;
|
|
|
|
vieter_tree_node_set(child, vieter_tree_node_right, right);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-19 22:45:22 +01:00
|
|
|
vieter_tree_error vieter_tree_node_insert(vieter_tree_node *root, uint64_t key,
|
2023-01-19 22:23:19 +01:00
|
|
|
void *data) {
|
2023-01-19 22:45:22 +01:00
|
|
|
vieter_tree_node *node = root;
|
|
|
|
vieter_tree_node *parent = root;
|
2023-01-19 22:23:19 +01:00
|
|
|
|
|
|
|
while (node != NULL) {
|
|
|
|
if (node->key == key) {
|
|
|
|
return vieter_tree_already_present;
|
|
|
|
}
|
|
|
|
|
|
|
|
parent = node;
|
2023-01-29 20:33:11 +01:00
|
|
|
node = node->children[key > parent->key];
|
2023-01-19 22:23:19 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
vieter_tree_node *new_node = vieter_tree_node_init();
|
|
|
|
new_node->key = key;
|
|
|
|
new_node->data = data;
|
|
|
|
|
2023-01-19 22:45:22 +01:00
|
|
|
vieter_tree_node_add_child(parent, key, new_node);
|
2023-01-20 13:23:53 +01:00
|
|
|
vieter_tree_node_balance_after_insert(new_node);
|
2023-01-19 22:23:19 +01:00
|
|
|
|
|
|
|
return vieter_tree_ok;
|
|
|
|
}
|
|
|
|
|
2023-01-19 22:45:22 +01:00
|
|
|
vieter_tree_error vieter_tree_node_search_node(vieter_tree_node **out,
|
|
|
|
vieter_tree_node *root,
|
|
|
|
uint64_t key) {
|
|
|
|
vieter_tree_node *node = root;
|
|
|
|
|
2023-01-19 22:23:19 +01:00
|
|
|
while (node != NULL) {
|
|
|
|
if (node->key == key) {
|
2023-01-19 22:45:22 +01:00
|
|
|
*out = node;
|
2023-01-19 22:23:19 +01:00
|
|
|
|
|
|
|
return vieter_tree_ok;
|
|
|
|
}
|
|
|
|
|
2023-01-29 20:33:11 +01:00
|
|
|
node = node->children[key > node->key];
|
2023-01-19 22:23:19 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return vieter_tree_not_present;
|
|
|
|
}
|
|
|
|
|
2023-01-19 22:45:22 +01:00
|
|
|
vieter_tree_error vieter_tree_node_search(void **out, vieter_tree_node *root,
|
2023-01-19 22:23:19 +01:00
|
|
|
uint64_t key) {
|
2023-01-19 22:45:22 +01:00
|
|
|
vieter_tree_node *target;
|
|
|
|
vieter_tree_error res = vieter_tree_node_search_node(&target, root, key);
|
|
|
|
|
|
|
|
if (res != vieter_tree_ok) {
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
*out = target->data;
|
|
|
|
|
|
|
|
return vieter_tree_ok;
|
|
|
|
}
|
|
|
|
|
2023-02-01 23:04:35 +01:00
|
|
|
vieter_tree_error
|
|
|
|
vieter_tree_node_remove(void **out, vieter_tree_node **root_ptr, uint64_t key) {
|
2023-01-19 22:45:22 +01:00
|
|
|
vieter_tree_node *target;
|
2023-02-01 23:04:35 +01:00
|
|
|
vieter_tree_error res = vieter_tree_node_search_node(&target, *root_ptr, key);
|
2023-01-19 22:45:22 +01:00
|
|
|
|
|
|
|
if (res != vieter_tree_ok) {
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
*out = target->data;
|
2023-02-01 23:04:35 +01:00
|
|
|
vieter_tree_node *possible_new_root;
|
2023-01-19 22:45:22 +01:00
|
|
|
|
2023-01-29 21:34:44 +01:00
|
|
|
if (target->children[0] != NULL && target->children[1] != NULL) {
|
2023-01-29 20:33:11 +01:00
|
|
|
vieter_tree_node *replacement = target->children[1];
|
2023-01-19 22:45:22 +01:00
|
|
|
|
2023-01-29 20:33:11 +01:00
|
|
|
while (replacement->children[0] != NULL) {
|
|
|
|
replacement = replacement->children[0];
|
2023-01-19 22:45:22 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
target->key = replacement->key;
|
|
|
|
target->data = replacement->data;
|
|
|
|
|
2023-02-01 23:04:35 +01:00
|
|
|
possible_new_root = vieter_tree_node_remove_balanced(replacement);
|
2023-01-29 21:34:44 +01:00
|
|
|
} else {
|
2023-02-01 23:04:35 +01:00
|
|
|
possible_new_root = vieter_tree_node_remove_balanced(target);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (possible_new_root == NULL) {
|
|
|
|
*root_ptr = NULL;
|
|
|
|
} else if (possible_new_root->parent == NULL) {
|
|
|
|
*root_ptr = possible_new_root;
|
2023-01-19 22:45:22 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return vieter_tree_ok;
|
2023-01-19 22:23:19 +01:00
|
|
|
}
|
2023-01-20 12:08:05 +01:00
|
|
|
|
2023-01-29 20:57:08 +01:00
|
|
|
void vieter_tree_node_set(vieter_tree_node *node, vieter_tree_node_flag flag,
|
|
|
|
bool set) {
|
|
|
|
if (set) {
|
|
|
|
node->flags |= flag;
|
|
|
|
} else {
|
|
|
|
node->flags &= ~flag;
|
|
|
|
}
|
2023-01-20 12:08:05 +01:00
|
|
|
}
|
|
|
|
|
2023-01-29 17:32:27 +01:00
|
|
|
bool vieter_tree_node_get(vieter_tree_node *node, vieter_tree_node_flag flag) {
|
2023-01-20 12:08:05 +01:00
|
|
|
return (node->flags & flag) != 0;
|
|
|
|
}
|
2023-02-02 14:10:35 +01:00
|
|
|
|
|
|
|
vieter_tree_node *vieter_tree_node_next(vieter_tree_node *node) {
|
|
|
|
if (node->children[1] != NULL) {
|
|
|
|
node = node->children[1];
|
|
|
|
|
|
|
|
while (node->children[0] != NULL) {
|
|
|
|
node = node->children[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
return node;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (node->parent != NULL &&
|
|
|
|
vieter_tree_node_get(node, vieter_tree_node_right)) {
|
|
|
|
node = node->parent;
|
|
|
|
}
|
|
|
|
|
|
|
|
return node->parent;
|
|
|
|
}
|