libvieter/src/tree/node.c

#include "node.h"

vieter_tree_node *vieter_tree_node_init() {
  return calloc(1, sizeof(vieter_tree_node));
}

void vieter_tree_node_add_child(vieter_tree_node *parent, uint64_t key,
                                vieter_tree_node *child) {
  if (parent == NULL) {
    return;
  }

  if (key < parent->key) {
    parent->left = child;
  } else {
    parent->right = child;
  }

  if (child != NULL) {
    child->parent = parent;
  }
}

void vieter_tree_node_replace(vieter_tree_node *to_replace,
                              vieter_tree_node *replacement) {
  to_replace->key = replacement->key;
  to_replace->data = replacement->data;
  to_replace->left = replacement->left;
  to_replace->right = replacement->right;
}

vieter_tree_error vieter_tree_node_insert(vieter_tree_node *root, uint64_t key,
                                          void *data) {
  vieter_tree_node *node = root;
  vieter_tree_node *parent = root;

  while (node != NULL) {
    if (node->key == key) {
      return vieter_tree_already_present;
    }

    parent = node;

    if (key < parent->key) {
      node = parent->left;
    } else {
      node = parent->right;
    }
  }

  vieter_tree_node *new_node = vieter_tree_node_init();
  new_node->key = key;
  new_node->data = data;

  vieter_tree_node_add_child(parent, key, new_node);

  return vieter_tree_ok;
}

vieter_tree_error vieter_tree_node_search_node(vieter_tree_node **out,
                                               vieter_tree_node *root,
                                               uint64_t key) {
  vieter_tree_node *node = root;

  while (node != NULL) {
    if (node->key == key) {
      *out = node;

      return vieter_tree_ok;
    }

    if (key < node->key) {
      node = node->left;
    } else {
      node = node->right;
    }
  }

  return vieter_tree_not_present;
}

vieter_tree_error vieter_tree_node_search(void **out, vieter_tree_node *root,
                                          uint64_t key) {
  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;
}

vieter_tree_node *vieter_tree_node_successor(vieter_tree_node *node) {
  if ((node->left != NULL) ^ (node->right != NULL)) {
    return node->left != NULL ? node->left : node->right;
  }

  node = node->right;

  while (node->left != NULL) {
    node = node->left;
  }

  return node;
}

vieter_tree_error vieter_tree_node_remove(void **out, vieter_tree_node *root,
                                          uint64_t key) {
  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;

  if (target->left == NULL && target->right == NULL) {
    vieter_tree_node_add_child(target->parent, target->key, NULL);

    free(target);
  } else if ((target->left == NULL) ^ (target->right == NULL)) {
    vieter_tree_node *child =
        target->left != NULL ? target->left : target->right;

    if (target->parent != NULL) {
      vieter_tree_node_add_child(target->parent, child->key, child);
      free(target);
    } else {
      vieter_tree_node_replace(target, child);
      free(child);
    }

  } else {
    vieter_tree_node *replacement = target->right;

    while (replacement->left != NULL) {
      replacement = replacement->left;
    }

    // We use replacement->key here because the right child can be NULL, so
    // reading its key isn't safe. Using replacement->key however, the child
    // will still get placed into the right location because of how binary
    // trees work.
    vieter_tree_node_add_child(replacement->parent, replacement->key,
                               replacement->right);

    target->key = replacement->key;
    target->data = replacement->data;

    free(replacement);
  }

  return vieter_tree_ok;
}