forked from vieter-v/libvieter
Compare commits
4 Commits
3fb027715c
...
b74a4e9326
Author | SHA1 | Date |
---|---|---|
Jef Roosens | b74a4e9326 | |
Jef Roosens | e5130a6383 | |
Jef Roosens | 193fc4b454 | |
Jef Roosens | 06fca6f5ae |
|
@ -16,7 +16,7 @@ vieter_tree_error vieter_tree_insert(vieter_tree *tree, uint64_t key,
|
||||||
tree->root = vieter_tree_node_init();
|
tree->root = vieter_tree_node_init();
|
||||||
tree->root->key = key;
|
tree->root->key = key;
|
||||||
tree->root->data = data;
|
tree->root->data = data;
|
||||||
vieter_tree_node_set(tree->root, vieter_node_black);
|
vieter_tree_node_set(tree->root, vieter_tree_node_black, true);
|
||||||
tree->size = 1;
|
tree->size = 1;
|
||||||
|
|
||||||
return vieter_tree_ok;
|
return vieter_tree_ok;
|
||||||
|
@ -80,13 +80,13 @@ void vieter_tree_free(vieter_tree *tree) {
|
||||||
stack = realloc(stack, capacity * sizeof(vieter_tree_node *));
|
stack = realloc(stack, capacity * sizeof(vieter_tree_node *));
|
||||||
}
|
}
|
||||||
|
|
||||||
if (node->left != NULL) {
|
if (node->children[0] != NULL) {
|
||||||
stack[size] = node->left;
|
stack[size] = node->children[0];
|
||||||
size++;
|
size++;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (node->right != NULL) {
|
if (node->children[1] != NULL) {
|
||||||
stack[size] = node->right;
|
stack[size] = node->children[1];
|
||||||
size++;
|
size++;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -99,9 +99,9 @@ end:
|
||||||
free(tree);
|
free(tree);
|
||||||
}
|
}
|
||||||
|
|
||||||
int vieter_tree_validate(vieter_tree *tree) {
|
bool vieter_tree_validate(vieter_tree *tree) {
|
||||||
if (tree->size == 0) {
|
if (tree->size == 0) {
|
||||||
return 0;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
// DFS to get expected black nodes
|
// DFS to get expected black nodes
|
||||||
|
@ -109,12 +109,13 @@ int vieter_tree_validate(vieter_tree *tree) {
|
||||||
vieter_tree_node *node = tree->root;
|
vieter_tree_node *node = tree->root;
|
||||||
|
|
||||||
while (node != NULL) {
|
while (node != NULL) {
|
||||||
if (vieter_tree_node_get(node, vieter_node_black)) {
|
if (vieter_tree_node_get(node, vieter_tree_node_black)) {
|
||||||
expected_black_nodes++;
|
expected_black_nodes++;
|
||||||
}
|
}
|
||||||
|
|
||||||
node = node->left;
|
node = node->children[0];
|
||||||
}
|
}
|
||||||
|
|
||||||
return vieter_tree_node_validate(tree->root, 0, expected_black_nodes);
|
return vieter_tree_node_get(tree->root, vieter_tree_node_black) &&
|
||||||
|
vieter_tree_node_validate(tree->root, 0, expected_black_nodes);
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,150 +1,127 @@
|
||||||
#include "vieter_tree_balancing.h"
|
#include "vieter_tree_balancing.h"
|
||||||
|
#include <string.h>
|
||||||
|
|
||||||
int vieter_tree_node_validate(vieter_tree_node *node,
|
bool vieter_tree_node_validate(vieter_tree_node *node,
|
||||||
uint64_t passed_black_nodes,
|
uint64_t passed_black_nodes,
|
||||||
uint64_t expected_black_nodes) {
|
uint64_t expected_black_nodes) {
|
||||||
if (vieter_tree_node_get(node, vieter_node_black)) {
|
// Path to NULL children should contain the same amount of black nodes
|
||||||
|
if (node == NULL) {
|
||||||
|
return passed_black_nodes == expected_black_nodes;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (vieter_tree_node_get(node, vieter_tree_node_black)) {
|
||||||
passed_black_nodes++;
|
passed_black_nodes++;
|
||||||
} else {
|
|
||||||
// A red node should have black child nodes
|
|
||||||
if ((node->left != NULL &&
|
|
||||||
!vieter_tree_node_get(node->left, vieter_node_black)) ||
|
|
||||||
(node->right != NULL &&
|
|
||||||
!vieter_tree_node_get(node->right, vieter_node_black))) {
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// All paths to a NULL child should have the same amount of black nodes
|
// Either the node itself is black, or its children are both either NULL or
|
||||||
if ((node->left == NULL || node->right == NULL) &&
|
// black.
|
||||||
passed_black_nodes != expected_black_nodes) {
|
bool correctly_colored_children =
|
||||||
return 1;
|
vieter_tree_node_get(node, vieter_tree_node_black) ||
|
||||||
}
|
((node->children[0] == NULL ||
|
||||||
|
vieter_tree_node_get(node->children[0], vieter_tree_node_black)) &&
|
||||||
|
(node->children[1] == NULL ||
|
||||||
|
vieter_tree_node_get(node->children[1], vieter_tree_node_black)));
|
||||||
|
|
||||||
if (node->left != NULL) {
|
return correctly_colored_children &&
|
||||||
if (vieter_tree_node_validate(node->left, passed_black_nodes,
|
vieter_tree_node_validate(node->children[0], passed_black_nodes,
|
||||||
expected_black_nodes) != 0) {
|
expected_black_nodes) &&
|
||||||
return 1;
|
vieter_tree_node_validate(node->children[1], passed_black_nodes,
|
||||||
}
|
expected_black_nodes);
|
||||||
}
|
|
||||||
|
|
||||||
if (node->right != NULL) {
|
|
||||||
if (vieter_tree_node_validate(node->right, passed_black_nodes,
|
|
||||||
expected_black_nodes) != 0) {
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
vieter_tree_node *vieter_tree_node_balance(vieter_tree_node *node) {
|
vieter_tree_node *vieter_tree_node_balance(vieter_tree_node *node) {
|
||||||
vieter_tree_node *parent = node->parent;
|
vieter_tree_node *parent = node->parent;
|
||||||
vieter_tree_node *grand_parent = parent->parent;
|
vieter_tree_node *grand_parent = parent->parent;
|
||||||
vieter_tree_node *root = grand_parent;
|
vieter_tree_node *root = grand_parent;
|
||||||
vieter_tree_node *left, *right;
|
vieter_tree_node *children[2];
|
||||||
vieter_tree_node *children[4];
|
vieter_tree_node *grand_children[4];
|
||||||
|
|
||||||
uint64_t key_root = root->key;
|
uint64_t key_root = root->key;
|
||||||
void *data_root = root->data;
|
void *data_root = root->data;
|
||||||
|
|
||||||
if (node->key < parent->key && parent->key < grand_parent->key) {
|
if (vieter_tree_node_get(node, vieter_tree_node_right)) {
|
||||||
root->key = parent->key;
|
children[0] = parent;
|
||||||
root->data = parent->data;
|
children[1] = node;
|
||||||
|
|
||||||
parent->key = key_root;
|
if (vieter_tree_node_get(parent, vieter_tree_node_right)) {
|
||||||
parent->data = data_root;
|
root->key = parent->key;
|
||||||
|
root->data = parent->data;
|
||||||
|
|
||||||
left = node;
|
parent->key = key_root;
|
||||||
right = parent;
|
parent->data = data_root;
|
||||||
|
|
||||||
children[0] = node->left;
|
grand_children[0] = grand_parent->children[0];
|
||||||
children[1] = node->right;
|
grand_children[1] = parent->children[0];
|
||||||
children[2] = parent->right;
|
grand_children[2] = node->children[0];
|
||||||
children[3] = grand_parent->right;
|
grand_children[3] = node->children[1];
|
||||||
} else if (node->key < parent->key && parent->key > grand_parent->key) {
|
} else {
|
||||||
root->key = node->key;
|
root->key = node->key;
|
||||||
root->data = node->data;
|
root->data = node->data;
|
||||||
|
|
||||||
node->key = key_root;
|
node->key = key_root;
|
||||||
node->data = data_root;
|
node->data = data_root;
|
||||||
|
|
||||||
left = node;
|
grand_children[0] = parent->children[0];
|
||||||
right = parent;
|
grand_children[1] = node->children[0];
|
||||||
|
grand_children[2] = node->children[1];
|
||||||
children[0] = grand_parent->left;
|
grand_children[3] = grand_parent->children[1];
|
||||||
children[1] = node->left;
|
}
|
||||||
children[2] = node->right;
|
|
||||||
children[3] = parent->right;
|
|
||||||
} else if (node->key > parent->key && parent->key < grand_parent->key) {
|
|
||||||
root->key = node->key;
|
|
||||||
root->data = node->data;
|
|
||||||
|
|
||||||
node->key = key_root;
|
|
||||||
node->data = data_root;
|
|
||||||
|
|
||||||
left = parent;
|
|
||||||
right = node;
|
|
||||||
|
|
||||||
children[0] = parent->left;
|
|
||||||
children[1] = node->left;
|
|
||||||
children[2] = node->right;
|
|
||||||
children[3] = grand_parent->right;
|
|
||||||
} else {
|
} else {
|
||||||
root->key = parent->key;
|
children[0] = node;
|
||||||
root->data = parent->data;
|
children[1] = parent;
|
||||||
|
|
||||||
parent->key = key_root;
|
if (vieter_tree_node_get(parent, vieter_tree_node_right)) {
|
||||||
parent->data = data_root;
|
root->key = node->key;
|
||||||
|
root->data = node->data;
|
||||||
|
|
||||||
left = parent;
|
node->key = key_root;
|
||||||
right = node;
|
node->data = data_root;
|
||||||
|
|
||||||
children[0] = grand_parent->left;
|
grand_children[0] = grand_parent->children[0];
|
||||||
children[1] = parent->left;
|
grand_children[1] = node->children[0];
|
||||||
children[2] = node->left;
|
grand_children[2] = node->children[1];
|
||||||
children[3] = node->right;
|
grand_children[3] = parent->children[1];
|
||||||
|
} else {
|
||||||
|
root->key = parent->key;
|
||||||
|
root->data = parent->data;
|
||||||
|
|
||||||
|
parent->key = key_root;
|
||||||
|
parent->data = data_root;
|
||||||
|
|
||||||
|
grand_children[0] = node->children[0];
|
||||||
|
grand_children[1] = node->children[1];
|
||||||
|
grand_children[2] = parent->children[1];
|
||||||
|
grand_children[3] = grand_parent->children[1];
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
vieter_tree_node_set(left, vieter_node_black);
|
vieter_tree_node_set(
|
||||||
vieter_tree_node_set(right, vieter_node_black);
|
root, vieter_tree_node_right,
|
||||||
vieter_tree_node_unset(root, vieter_node_black);
|
vieter_tree_node_get(grand_parent, vieter_tree_node_right));
|
||||||
|
|
||||||
left->left = children[0];
|
vieter_tree_node_set(children[0], vieter_tree_node_black, true);
|
||||||
left->right = children[1];
|
vieter_tree_node_set(children[1], vieter_tree_node_black, true);
|
||||||
|
|
||||||
if (children[0] != NULL)
|
vieter_tree_node_set(root, vieter_tree_node_black, false);
|
||||||
children[0]->parent = left;
|
|
||||||
|
|
||||||
if (children[1] != NULL)
|
vieter_tree_node_set_children(children[0], grand_children);
|
||||||
children[1]->parent = left;
|
vieter_tree_node_set_children(children[1], grand_children + 2);
|
||||||
|
vieter_tree_node_set_children(root, children);
|
||||||
right->left = children[2];
|
|
||||||
right->right = children[3];
|
|
||||||
|
|
||||||
if (children[2] != NULL)
|
|
||||||
children[2]->parent = right;
|
|
||||||
|
|
||||||
if (children[3] != NULL)
|
|
||||||
children[3]->parent = right;
|
|
||||||
|
|
||||||
root->left = left;
|
|
||||||
root->right = right;
|
|
||||||
left->parent = root;
|
|
||||||
right->parent = root;
|
|
||||||
|
|
||||||
return root;
|
return root;
|
||||||
}
|
}
|
||||||
|
|
||||||
void vieter_tree_node_balance_after_insert(vieter_tree_node *node) {
|
void vieter_tree_node_balance_after_insert(vieter_tree_node *node) {
|
||||||
while (!vieter_tree_node_get(node, vieter_node_black) &&
|
while (!vieter_tree_node_get(node, vieter_tree_node_black) &&
|
||||||
node->parent != NULL &&
|
node->parent != NULL &&
|
||||||
!vieter_tree_node_get(node->parent, vieter_node_black)) {
|
!vieter_tree_node_get(node->parent, vieter_tree_node_black)) {
|
||||||
node = vieter_tree_node_balance(node);
|
node = vieter_tree_node_balance(node);
|
||||||
}
|
}
|
||||||
|
|
||||||
// The root must always be black
|
// The root must always be black
|
||||||
if (node->parent == NULL) {
|
if (node->parent == NULL) {
|
||||||
vieter_tree_node_set(node, vieter_node_black);
|
vieter_tree_node_set(node, vieter_tree_node_black, true);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void vieter_tree_node_remove_balanced(vieter_tree_node *node) {}
|
||||||
|
|
|
@ -3,6 +3,17 @@
|
||||||
|
|
||||||
#include "vieter_tree_node.h"
|
#include "vieter_tree_node.h"
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Ensure the tree remains a valid red-black tree after having inserting the
|
||||||
|
* node.
|
||||||
|
*/
|
||||||
void vieter_tree_node_balance_after_insert(vieter_tree_node *node);
|
void vieter_tree_node_balance_after_insert(vieter_tree_node *node);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Remove the given node, ensuring the tree remains a valid red-black tree.
|
||||||
|
*
|
||||||
|
* @param node node to remove. This node should have at least one NULL child.
|
||||||
|
*/
|
||||||
|
void vieter_tree_node_remove_balanced(vieter_tree_node *node);
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -1,8 +1,10 @@
|
||||||
#include "vieter_tree.h"
|
#include "vieter_tree.h"
|
||||||
|
|
||||||
|
#include <stdbool.h>
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* Inspect whether the tree is still a valid red-black-tree.
|
* Inspect whether the tree is still a valid red-black-tree.
|
||||||
*
|
*
|
||||||
* @return 0 if correct, 1 if not.
|
* @return true if valid, false otherwise.
|
||||||
*/
|
*/
|
||||||
int vieter_tree_validate(vieter_tree *tree);
|
bool vieter_tree_validate(vieter_tree *tree);
|
||||||
|
|
|
@ -1,6 +1,8 @@
|
||||||
#include "vieter_tree_node.h"
|
#include "vieter_tree_node.h"
|
||||||
#include "vieter_tree_balancing.h"
|
#include "vieter_tree_balancing.h"
|
||||||
|
|
||||||
|
#include <string.h>
|
||||||
|
|
||||||
vieter_tree_node *vieter_tree_node_init() {
|
vieter_tree_node *vieter_tree_node_init() {
|
||||||
return calloc(1, sizeof(vieter_tree_node));
|
return calloc(1, sizeof(vieter_tree_node));
|
||||||
}
|
}
|
||||||
|
@ -13,14 +15,24 @@ void vieter_tree_node_add_child(vieter_tree_node *parent, uint64_t key,
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (key < parent->key) {
|
bool side = key > parent->key;
|
||||||
parent->left = child;
|
parent->children[side] = child;
|
||||||
} else {
|
|
||||||
parent->right = child;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (child != NULL) {
|
if (child != NULL) {
|
||||||
child->parent = parent;
|
child->parent = parent;
|
||||||
|
vieter_tree_node_set(child, vieter_tree_node_right, side);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
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);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -28,14 +40,7 @@ void vieter_tree_node_replace_with_child(vieter_tree_node *to_replace,
|
||||||
vieter_tree_node *replacement) {
|
vieter_tree_node *replacement) {
|
||||||
to_replace->key = replacement->key;
|
to_replace->key = replacement->key;
|
||||||
to_replace->data = replacement->data;
|
to_replace->data = replacement->data;
|
||||||
to_replace->left = replacement->left;
|
vieter_tree_node_set_children(to_replace, replacement->children);
|
||||||
to_replace->right = replacement->right;
|
|
||||||
|
|
||||||
if (to_replace->left != NULL)
|
|
||||||
to_replace->left->parent = to_replace;
|
|
||||||
|
|
||||||
if (to_replace->right != NULL)
|
|
||||||
to_replace->right->parent = to_replace;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
vieter_tree_error vieter_tree_node_insert(vieter_tree_node *root, uint64_t key,
|
vieter_tree_error vieter_tree_node_insert(vieter_tree_node *root, uint64_t key,
|
||||||
|
@ -49,12 +54,7 @@ vieter_tree_error vieter_tree_node_insert(vieter_tree_node *root, uint64_t key,
|
||||||
}
|
}
|
||||||
|
|
||||||
parent = node;
|
parent = node;
|
||||||
|
node = node->children[key > parent->key];
|
||||||
if (key < parent->key) {
|
|
||||||
node = parent->left;
|
|
||||||
} else {
|
|
||||||
node = parent->right;
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
vieter_tree_node *new_node = vieter_tree_node_init();
|
vieter_tree_node *new_node = vieter_tree_node_init();
|
||||||
|
@ -79,11 +79,7 @@ vieter_tree_error vieter_tree_node_search_node(vieter_tree_node **out,
|
||||||
return vieter_tree_ok;
|
return vieter_tree_ok;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (key < node->key) {
|
node = node->children[key > node->key];
|
||||||
node = node->left;
|
|
||||||
} else {
|
|
||||||
node = node->right;
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
return vieter_tree_not_present;
|
return vieter_tree_not_present;
|
||||||
|
@ -114,13 +110,13 @@ vieter_tree_error vieter_tree_node_remove(void **out, vieter_tree_node *root,
|
||||||
|
|
||||||
*out = target->data;
|
*out = target->data;
|
||||||
|
|
||||||
if (target->left == NULL && target->right == NULL) {
|
if (target->children[0] == NULL && target->children[1] == NULL) {
|
||||||
vieter_tree_node_add_child(target->parent, target->key, NULL);
|
vieter_tree_node_add_child(target->parent, target->key, NULL);
|
||||||
|
|
||||||
vieter_tree_node_free(target);
|
vieter_tree_node_free(target);
|
||||||
} else if ((target->left == NULL) ^ (target->right == NULL)) {
|
} else if ((target->children[0] == NULL) ^ (target->children[1] == NULL)) {
|
||||||
vieter_tree_node *child =
|
vieter_tree_node *child =
|
||||||
target->left != NULL ? target->left : target->right;
|
target->children[0] != NULL ? target->children[0] : target->children[1];
|
||||||
|
|
||||||
if (target->parent != NULL) {
|
if (target->parent != NULL) {
|
||||||
vieter_tree_node_add_child(target->parent, child->key, child);
|
vieter_tree_node_add_child(target->parent, child->key, child);
|
||||||
|
@ -131,10 +127,10 @@ vieter_tree_error vieter_tree_node_remove(void **out, vieter_tree_node *root,
|
||||||
}
|
}
|
||||||
|
|
||||||
} else {
|
} else {
|
||||||
vieter_tree_node *replacement = target->right;
|
vieter_tree_node *replacement = target->children[1];
|
||||||
|
|
||||||
while (replacement->left != NULL) {
|
while (replacement->children[0] != NULL) {
|
||||||
replacement = replacement->left;
|
replacement = replacement->children[0];
|
||||||
}
|
}
|
||||||
|
|
||||||
// We use replacement->key here because the right child can be NULL, so
|
// We use replacement->key here because the right child can be NULL, so
|
||||||
|
@ -142,7 +138,7 @@ vieter_tree_error vieter_tree_node_remove(void **out, vieter_tree_node *root,
|
||||||
// will still get placed into the right location because of how binary
|
// will still get placed into the right location because of how binary
|
||||||
// trees work.
|
// trees work.
|
||||||
vieter_tree_node_add_child(replacement->parent, replacement->key,
|
vieter_tree_node_add_child(replacement->parent, replacement->key,
|
||||||
replacement->right);
|
replacement->children[1]);
|
||||||
|
|
||||||
target->key = replacement->key;
|
target->key = replacement->key;
|
||||||
target->data = replacement->data;
|
target->data = replacement->data;
|
||||||
|
@ -153,14 +149,15 @@ vieter_tree_error vieter_tree_node_remove(void **out, vieter_tree_node *root,
|
||||||
return vieter_tree_ok;
|
return vieter_tree_ok;
|
||||||
}
|
}
|
||||||
|
|
||||||
void vieter_tree_node_set(vieter_tree_node *node, vieter_node_flag flag) {
|
void vieter_tree_node_set(vieter_tree_node *node, vieter_tree_node_flag flag,
|
||||||
node->flags |= flag;
|
bool set) {
|
||||||
|
if (set) {
|
||||||
|
node->flags |= flag;
|
||||||
|
} else {
|
||||||
|
node->flags &= ~flag;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void vieter_tree_node_unset(vieter_tree_node *node, vieter_node_flag flag) {
|
bool vieter_tree_node_get(vieter_tree_node *node, vieter_tree_node_flag flag) {
|
||||||
node->flags &= ~flag;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool vieter_tree_node_get(vieter_tree_node *node, vieter_node_flag flag) {
|
|
||||||
return (node->flags & flag) != 0;
|
return (node->flags & flag) != 0;
|
||||||
}
|
}
|
||||||
|
|
|
@ -5,18 +5,18 @@
|
||||||
#include <stdint.h>
|
#include <stdint.h>
|
||||||
#include <stdbool.h>
|
#include <stdbool.h>
|
||||||
|
|
||||||
#define VIETER_NODE_BLACK ((uint8_t)1)
|
typedef enum vieter_tree_node_flag {
|
||||||
|
vieter_tree_node_black = ((uint8_t)1) << 0,
|
||||||
typedef enum vieter_node_flag {
|
// This flag is used to index the children array. If this flag isn't set,
|
||||||
vieter_node_black = ((uint8_t)1) << 0
|
// it'll evaluate to false, or index 0 in the children array.
|
||||||
} vieter_node_flag;
|
vieter_tree_node_right = ((uint8_t)1) << 1
|
||||||
|
} vieter_tree_node_flag;
|
||||||
|
|
||||||
typedef struct vieter_tree_node {
|
typedef struct vieter_tree_node {
|
||||||
uint64_t key;
|
uint64_t key;
|
||||||
void *data;
|
void *data;
|
||||||
struct vieter_tree_node *parent;
|
struct vieter_tree_node *parent;
|
||||||
struct vieter_tree_node *left;
|
struct vieter_tree_node *children[2];
|
||||||
struct vieter_tree_node *right;
|
|
||||||
uint8_t flags;
|
uint8_t flags;
|
||||||
} vieter_tree_node;
|
} vieter_tree_node;
|
||||||
|
|
||||||
|
@ -26,20 +26,24 @@ void vieter_tree_node_free(vieter_tree_node *node);
|
||||||
|
|
||||||
vieter_tree_error vieter_tree_node_insert(vieter_tree_node *root, uint64_t key, void *data);
|
vieter_tree_error vieter_tree_node_insert(vieter_tree_node *root, uint64_t key, void *data);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Return the node representing the requested value.
|
||||||
|
*/
|
||||||
vieter_tree_error vieter_tree_node_search_node(vieter_tree_node **out, vieter_tree_node *root, uint64_t key);
|
vieter_tree_error vieter_tree_node_search_node(vieter_tree_node **out, vieter_tree_node *root, uint64_t key);
|
||||||
|
|
||||||
vieter_tree_error vieter_tree_node_search(void **out, vieter_tree_node *root, uint64_t key);
|
vieter_tree_error vieter_tree_node_search(void **out, vieter_tree_node *root, uint64_t key);
|
||||||
|
|
||||||
vieter_tree_error vieter_tree_node_remove(void **out, vieter_tree_node *root, uint64_t key);
|
vieter_tree_error vieter_tree_node_remove(void **out, vieter_tree_node *root, uint64_t key);
|
||||||
|
|
||||||
void vieter_tree_node_replace(vieter_tree_node *to_replace, vieter_tree_node *replacement);
|
void vieter_tree_node_replace_with_child(vieter_tree_node *to_replace, vieter_tree_node *replacement);
|
||||||
|
|
||||||
void vieter_tree_node_set(vieter_tree_node *node, vieter_node_flag flag);
|
void vieter_tree_node_set(vieter_tree_node *node, vieter_tree_node_flag flag, bool value);
|
||||||
void vieter_tree_node_unset(vieter_tree_node *node, vieter_node_flag flag);
|
bool vieter_tree_node_get(vieter_tree_node *node, vieter_tree_node_flag flag);
|
||||||
bool vieter_tree_node_get(vieter_tree_node *node, vieter_node_flag flag);
|
|
||||||
|
|
||||||
void vieter_tree_node_add_child(vieter_tree_node *parent, uint64_t key,
|
void vieter_tree_node_add_child(vieter_tree_node *parent, uint64_t key,
|
||||||
vieter_tree_node *child);
|
vieter_tree_node *child);
|
||||||
|
void vieter_tree_node_set_children(vieter_tree_node *parent, vieter_tree_node **children);
|
||||||
|
|
||||||
int vieter_tree_node_validate(vieter_tree_node *node, uint64_t passed_black_nodes, uint64_t expected_black_nodes);
|
bool vieter_tree_node_validate(vieter_tree_node *node, uint64_t passed_black_nodes, uint64_t expected_black_nodes);
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -18,7 +18,7 @@ void test_insert() {
|
||||||
for (uint64_t i = 0; i < 250; i++) {
|
for (uint64_t i = 0; i < 250; i++) {
|
||||||
TEST_CHECK(vieter_tree_insert(tree, i, NULL) == vieter_tree_ok);
|
TEST_CHECK(vieter_tree_insert(tree, i, NULL) == vieter_tree_ok);
|
||||||
TEST_SIZE(tree, i + 1);
|
TEST_SIZE(tree, i + 1);
|
||||||
TEST_CHECK(vieter_tree_validate(tree) == 0);
|
TEST_CHECK(vieter_tree_validate(tree));
|
||||||
}
|
}
|
||||||
|
|
||||||
void *out;
|
void *out;
|
||||||
|
@ -37,7 +37,7 @@ void test_remove() {
|
||||||
|
|
||||||
for (uint64_t i = 0; i < 250; i++) {
|
for (uint64_t i = 0; i < 250; i++) {
|
||||||
TEST_CHECK(vieter_tree_insert(tree, i, NULL) == vieter_tree_ok);
|
TEST_CHECK(vieter_tree_insert(tree, i, NULL) == vieter_tree_ok);
|
||||||
TEST_CHECK(vieter_tree_validate(tree) == 0);
|
TEST_CHECK(vieter_tree_validate(tree));
|
||||||
}
|
}
|
||||||
|
|
||||||
void *out;
|
void *out;
|
||||||
|
@ -45,7 +45,7 @@ void test_remove() {
|
||||||
for (uint64_t i = 0; i < 25; i++) {
|
for (uint64_t i = 0; i < 25; i++) {
|
||||||
TEST_CHECK(vieter_tree_search(&out, tree, i) == vieter_tree_ok);
|
TEST_CHECK(vieter_tree_search(&out, tree, i) == vieter_tree_ok);
|
||||||
TEST_CHECK(vieter_tree_remove(&out, tree, i) == vieter_tree_ok);
|
TEST_CHECK(vieter_tree_remove(&out, tree, i) == vieter_tree_ok);
|
||||||
TEST_CHECK(vieter_tree_validate(tree) == 0);
|
TEST_CHECK(vieter_tree_validate(tree));
|
||||||
TEST_CHECK(vieter_tree_search(&out, tree, i) == vieter_tree_not_present);
|
TEST_CHECK(vieter_tree_search(&out, tree, i) == vieter_tree_not_present);
|
||||||
TEST_SIZE(tree, 250 - i - 1);
|
TEST_SIZE(tree, 250 - i - 1);
|
||||||
}
|
}
|
||||||
|
|
Loading…
Reference in New Issue