refactor: decouple trie into static library
This commit is contained in:
parent
17dcc1db06
commit
fb4a9a3b2e
GPG key ID:
B75D4F293C7052DB
12 changed files with 1967 additions and 7 deletions
428
src/trie/trie.c
428
src/trie/trie.c
|
|
@ -1,428 +0,0 @@
|
|||
#include <pthread.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "trie.h"
|
||||
#include "trie_entry.h"
|
||||
#include "trie_node.h"
|
||||
|
||||
typedef struct ttrie {
|
||||
TrieNode *root;
|
||||
size_t size;
|
||||
char *file_path;
|
||||
pthread_rwlock_t lock;
|
||||
} Trie;
|
||||
|
||||
TrieExitCode trie_add_no_lock(Trie *trie, const char *key, Entry *entry);
|
||||
|
||||
/**
|
||||
* Allocate and initialize an empty Trie
|
||||
*
|
||||
* @return pointer to the empty Trie
|
||||
*/
|
||||
TrieExitCode trie_init(Trie **trie_ptr, const char *file_path) {
|
||||
// Allocate & initialize trie
|
||||
Trie *trie = calloc(1, sizeof(Trie));
|
||||
trie->root = tnode_init();
|
||||
pthread_rwlock_init(&trie->lock, NULL);
|
||||
|
||||
if (file_path == NULL) {
|
||||
trie->file_path = NULL;
|
||||
*trie_ptr = trie;
|
||||
return Ok;
|
||||
}
|
||||
|
||||
trie->file_path = strdup(file_path);
|
||||
|
||||
// Populate trie with data from file
|
||||
FILE *fp = fopen(file_path, "r");
|
||||
|
||||
if (fp == NULL) {
|
||||
return FileError;
|
||||
}
|
||||
|
||||
// We read in lines of at most 8192 characters (sounds like enough)
|
||||
char buffer[8192];
|
||||
EntryType type;
|
||||
Entry *entry;
|
||||
int i, j;
|
||||
TrieExitCode status;
|
||||
|
||||
while (fgets(buffer, 8192, fp)) {
|
||||
i = 0;
|
||||
|
||||
// Move index in buffer until we encounter first space character
|
||||
while (buffer[i] != ' ') {
|
||||
i++;
|
||||
}
|
||||
|
||||
// Split the buffer into two strings, the key and the payload
|
||||
buffer[i] = '\0';
|
||||
|
||||
type = entry_type_from_char(buffer[i + 1]);
|
||||
|
||||
// Skip type character & its surrounding spaces
|
||||
j = i + 3;
|
||||
|
||||
// Now remove the newline character
|
||||
while (buffer[j] != '\n') {
|
||||
j++;
|
||||
}
|
||||
|
||||
buffer[j] = '\0';
|
||||
|
||||
entry = entry_new(type, buffer + i + 3);
|
||||
status = trie_add_no_lock(trie, buffer, entry);
|
||||
|
||||
if (status != Ok) {
|
||||
trie_free(trie);
|
||||
return status;
|
||||
}
|
||||
}
|
||||
|
||||
fclose(fp);
|
||||
|
||||
*trie_ptr = trie;
|
||||
|
||||
return Ok;
|
||||
}
|
||||
|
||||
/**
|
||||
* De-allocate a TernaryTree by freeing its entire underlying structure.
|
||||
*
|
||||
* @param trie trie to free
|
||||
*/
|
||||
void trie_free(Trie *trie) {
|
||||
tnode_free(trie->root);
|
||||
free(trie);
|
||||
}
|
||||
|
||||
typedef struct searchresult {
|
||||
TrieNode *parent;
|
||||
TrieNode *child;
|
||||
} SearchResult;
|
||||
|
||||
SearchResult trie_search_node_len(Trie *trie, const char *key, size_t key_len) {
|
||||
SearchResult out = {NULL, NULL};
|
||||
|
||||
size_t i = 0;
|
||||
TrieNode **node_ptr = &(trie->root);
|
||||
TrieNode **child_ptr;
|
||||
|
||||
do {
|
||||
child_ptr = tnode_search(*node_ptr, key[i], false);
|
||||
|
||||
// We don't have to check whether *node_ptr is NULL, because if it was
|
||||
// NULL, it wouldn't be in the binary tree.
|
||||
if (child_ptr == NULL) {
|
||||
return out;
|
||||
}
|
||||
|
||||
i++;
|
||||
|
||||
if (memcmp((*child_ptr)->string, key + i, (*child_ptr)->string_len) != 0) {
|
||||
return out;
|
||||
}
|
||||
|
||||
i += (*child_ptr)->string_len;
|
||||
|
||||
if (i < key_len) {
|
||||
node_ptr = child_ptr;
|
||||
}
|
||||
} while (i < key_len);
|
||||
|
||||
// At this point, we've either arrived at an empty child, or traversed through
|
||||
// the entire string. Therefore, all we have to do is check whether we're at
|
||||
// the end of the string and if node represents a string.
|
||||
if (i == key_len && (*child_ptr)->represents) {
|
||||
out.parent = *node_ptr;
|
||||
out.child = *child_ptr;
|
||||
}
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
SearchResult trie_search_node(Trie *trie, const char *key) {
|
||||
return trie_search_node_len(trie, key, strlen(key));
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns whether the given string is present in the trie.
|
||||
*
|
||||
* @param trie trie to look in
|
||||
* @param string string to look up
|
||||
* @return true if the string is present in the trie, false otherwise
|
||||
*/
|
||||
TrieExitCode trie_search_len(Trie *trie, Entry **entry_ptr, const char *key,
|
||||
size_t key_len) {
|
||||
SearchResult res = trie_search_node_len(trie, key, key_len);
|
||||
|
||||
if (res.child == NULL) {
|
||||
return NotFound;
|
||||
}
|
||||
|
||||
*entry_ptr = res.child->entry;
|
||||
|
||||
return Ok;
|
||||
}
|
||||
|
||||
TrieExitCode trie_search(Trie *trie, Entry **entry_ptr, const char *key) {
|
||||
return trie_search_len(trie, entry_ptr, key, strlen(key));
|
||||
}
|
||||
|
||||
/**
|
||||
* Add the given string to the Trie.
|
||||
*
|
||||
* @param trie trie to add string to
|
||||
* @param string string to add
|
||||
* @return true if the string wasn't present in the trie and thus added, false
|
||||
* otherwise
|
||||
*/
|
||||
TrieExitCode trie_add_len_no_lock(Trie *trie, const char *key, size_t key_len,
|
||||
Entry *entry) {
|
||||
size_t i = 0;
|
||||
uint8_t offset;
|
||||
TrieNode **node_ptr = &(trie->root);
|
||||
TrieNode **child_node_ptr;
|
||||
TrieNode *child_node;
|
||||
|
||||
do {
|
||||
offset = 0;
|
||||
child_node_ptr = tnode_search(*node_ptr, key[i], true);
|
||||
|
||||
i++;
|
||||
|
||||
// We've reached a NULL child, so we add the remaining part of the string
|
||||
// here
|
||||
if (*child_node_ptr == NULL) {
|
||||
child_node = tnode_init();
|
||||
|
||||
while (offset < TRIE_MAX_SKIP_SIZE && i + offset < key_len) {
|
||||
offset++;
|
||||
}
|
||||
|
||||
memcpy(child_node->string, key + i, offset);
|
||||
|
||||
child_node->string_len = offset;
|
||||
*child_node_ptr = child_node;
|
||||
|
||||
// If the remaining part of the string is still longer than the maximum
|
||||
// allowed skip length, we continue through the loop. The next iteration
|
||||
// will enter this if statement again, and perform the same loop, until
|
||||
// the string is fully added to the trie.
|
||||
if (i + offset < key_len) {
|
||||
node_ptr = child_node_ptr;
|
||||
i += offset;
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
child_node->represents = true;
|
||||
child_node->entry = entry;
|
||||
|
||||
trie->size++;
|
||||
return Ok;
|
||||
}
|
||||
|
||||
while (offset < (*child_node_ptr)->string_len) {
|
||||
// String no longer aligns with edge, so we have to split
|
||||
if (key[i + offset] != (*child_node_ptr)->string[offset]) {
|
||||
TrieNode *split_node = tnode_init();
|
||||
child_node = *child_node_ptr;
|
||||
|
||||
// New string of the split node is the prefix that we were able
|
||||
// to skip
|
||||
if (offset > 0) {
|
||||
memcpy(split_node->string, child_node->string, offset);
|
||||
split_node->string_len = offset;
|
||||
}
|
||||
|
||||
// split_node replaces child_node as the child of node
|
||||
*child_node_ptr = split_node;
|
||||
TrieNode **new_node_ptr =
|
||||
tnode_search(split_node, child_node->string[offset], true);
|
||||
*new_node_ptr = child_node;
|
||||
|
||||
// child_node has now become a child of split_node, so we update its
|
||||
// string accordingely by removing the skipped prefix + the one
|
||||
// character that's already stored by being a child of split_node
|
||||
/* char *old_string = child_node->string.ptr; */
|
||||
uint8_t new_skip_len = child_node->string_len - (offset + 1);
|
||||
|
||||
if (new_skip_len > 0) {
|
||||
char old_string[TRIE_MAX_SKIP_SIZE];
|
||||
memcpy(old_string, child_node->string + offset + 1, new_skip_len);
|
||||
memcpy(child_node->string, old_string, new_skip_len);
|
||||
}
|
||||
|
||||
child_node->string_len = new_skip_len;
|
||||
|
||||
// The while loop will exit either way after this has happened, as
|
||||
// child_node is now split_node and split_node's len is already set to
|
||||
// offset.
|
||||
break;
|
||||
}
|
||||
|
||||
offset++;
|
||||
}
|
||||
|
||||
node_ptr = child_node_ptr;
|
||||
|
||||
i += offset;
|
||||
} while (i < key_len);
|
||||
|
||||
if ((*child_node_ptr)->represents) {
|
||||
return AlreadyPresent;
|
||||
}
|
||||
|
||||
(*child_node_ptr)->represents = true;
|
||||
(*child_node_ptr)->entry = entry;
|
||||
trie->size++;
|
||||
return Ok;
|
||||
}
|
||||
|
||||
TrieExitCode trie_add_no_lock(Trie *trie, const char *key, Entry *entry) {
|
||||
return trie_add_len_no_lock(trie, key, strlen(key), entry);
|
||||
}
|
||||
|
||||
TrieExitCode trie_add_len(Trie *trie, const char *key, size_t key_len,
|
||||
Entry *entry) {
|
||||
if (trie->file_path != NULL) {
|
||||
// Easiest way to make sure we don't add duplicate entries
|
||||
// We use an internal function that doesn't require a read lock, as we're
|
||||
// already inside a write lock
|
||||
if (trie_search_node_len(trie, key, key_len).child != NULL) {
|
||||
return AlreadyPresent;
|
||||
}
|
||||
|
||||
FILE *fp = fopen(trie->file_path, "a");
|
||||
|
||||
if (fp == NULL) {
|
||||
return FileError;
|
||||
}
|
||||
|
||||
fputs(key, fp);
|
||||
fputs(" ", fp);
|
||||
fputc(entry_type_to_char(entry->type), fp);
|
||||
fputs(" ", fp);
|
||||
fputs(entry->string, fp);
|
||||
fputs("\n", fp);
|
||||
|
||||
fclose(fp);
|
||||
}
|
||||
|
||||
// This function *should* always return Ok. Otherwise, the function would've
|
||||
// exited because the string was found in the trie.
|
||||
return trie_add_len_no_lock(trie, key, key_len, entry);
|
||||
}
|
||||
|
||||
TrieExitCode trie_add(Trie *trie, const char *key, Entry *entry) {
|
||||
return trie_add_len(trie, key, strlen(key), entry);
|
||||
}
|
||||
|
||||
TrieExitCode trie_add_random(Trie *trie, char **key_ptr, Entry *entry,
|
||||
bool secure) {
|
||||
// Generate random key
|
||||
bool ok = false;
|
||||
int key_length = secure ? RANDOM_KEY_LENGTH_LONG : RANDOM_KEY_LENGTH_SHORT;
|
||||
char *key = malloc(key_length + 1);
|
||||
key[key_length] = '\0';
|
||||
|
||||
// We naively generate new keys until we find a key that isn't in the trie
|
||||
// yet. With charset_len ** RANDOM_KEY_LENGTH sufficiently large, this isn't a
|
||||
// problem, because the chances of collisions are extremely small.
|
||||
while (!ok) {
|
||||
for (int i = 0; i < key_length; i++) {
|
||||
key[i] = charset[rand() % charset_len];
|
||||
}
|
||||
|
||||
ok = trie_search_node(trie, key).child == NULL;
|
||||
}
|
||||
|
||||
TrieExitCode return_value = trie_add(trie, key, entry);
|
||||
|
||||
if (return_value == Ok) {
|
||||
*key_ptr = key;
|
||||
} else {
|
||||
free(key);
|
||||
}
|
||||
|
||||
return return_value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove the given string from a Trie.
|
||||
*
|
||||
* @param trie trie to remove string from
|
||||
* @param string string to remove
|
||||
* @return true if the string was in the trie and thus removed, false otherwise
|
||||
*/
|
||||
/* bool trie_remove(Trie *trie, const char *string) { */
|
||||
/* pthread_rwlock_wrlock(&trie->lock); */
|
||||
|
||||
/* bool return_value = false; */
|
||||
|
||||
/* SearchResult res = trie_search_node(trie, string); */
|
||||
|
||||
/* if (res.child == NULL) { */
|
||||
/* goto end; */
|
||||
/* } */
|
||||
|
||||
/* trie->size--; */
|
||||
/* return_value = true; */
|
||||
|
||||
/* if (res.parent != NULL) { */
|
||||
/* // We're removing a full leaf, so we calculate the offset of the
|
||||
* character */
|
||||
/* // to remove from the parent */
|
||||
/* if (res.child->type == 2) { */
|
||||
/* size_t str_len = strlen(string); */
|
||||
/* size_t suffix_len = strlen(res.child->ptr.string); */
|
||||
|
||||
/* tnode_remove(res.parent, string[str_len - suffix_len - 1]); */
|
||||
/* } */
|
||||
/* // In the other case, the character to remove from the parent is the last
|
||||
*/
|
||||
/* // character of the string */
|
||||
/* else if (res.child->size == 0) { */
|
||||
/* size_t i = 0; */
|
||||
|
||||
/* while (string[i + 1] != DELIMITER) { */
|
||||
/* i++; */
|
||||
/* } */
|
||||
|
||||
/* tnode_remove(res.parent, string[i]); */
|
||||
/* } else { */
|
||||
/* res.child->type = 0; */
|
||||
|
||||
/* goto end; */
|
||||
/* } */
|
||||
|
||||
/* tnode_free(res.child); */
|
||||
/* } */
|
||||
/* // We're in the root here */
|
||||
/* else { */
|
||||
/* res.child->type = 0; */
|
||||
/* } */
|
||||
|
||||
/* end: */
|
||||
/* pthread_rwlock_unlock(&trie->lock); */
|
||||
|
||||
/* return return_value; */
|
||||
/* } */
|
||||
|
||||
/**
|
||||
* Return the current size of the given trie.
|
||||
*
|
||||
* @param trie trie to return size for
|
||||
* @return size of the trie
|
||||
*/
|
||||
size_t trie_size(Trie *trie) { return trie->size; }
|
||||
|
||||
int trie_rlock(Trie *trie) { return pthread_rwlock_rdlock(&trie->lock); }
|
||||
|
||||
int trie_wlock(Trie *trie) { return pthread_rwlock_wrlock(&trie->lock); }
|
||||
|
||||
int trie_unlock(Trie *trie) { return pthread_rwlock_unlock(&trie->lock); }
|
||||
|
|
@ -1,37 +0,0 @@
|
|||
#include "trie_entry.h"
|
||||
#include <stdlib.h>
|
||||
|
||||
EntryType entry_type_from_char(char c) {
|
||||
switch (c) {
|
||||
case '0':
|
||||
return Redirect;
|
||||
case '1':
|
||||
return Paste;
|
||||
default:
|
||||
return Unknown;
|
||||
}
|
||||
}
|
||||
|
||||
char entry_type_to_char(EntryType et) {
|
||||
switch (et) {
|
||||
case Redirect:
|
||||
return '0';
|
||||
case Paste:
|
||||
return '1';
|
||||
default:
|
||||
return '\0';
|
||||
}
|
||||
}
|
||||
|
||||
Entry *entry_new(EntryType type, const char *string) {
|
||||
Entry *entry = malloc(sizeof(Entry));
|
||||
entry->type = type;
|
||||
|
||||
if (string != NULL) {
|
||||
entry->string = strdup(string);
|
||||
} else {
|
||||
entry->string = NULL;
|
||||
}
|
||||
|
||||
return entry;
|
||||
}
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
#include "trie.h"
|
||||
|
||||
EntryType entry_type_from_char(char c);
|
||||
|
||||
char entry_type_to_char(EntryType et);
|
||||
|
||||
Entry *entry_new(EntryType type, const char *string);
|
||||
|
|
@ -1,265 +0,0 @@
|
|||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "trie_node.h"
|
||||
|
||||
/**
|
||||
* Allocate and initialize a new TrieInnerNode representing a given
|
||||
* character.
|
||||
*
|
||||
* @param c character to represent
|
||||
* @return pointer to newly allocated struct
|
||||
*/
|
||||
TrieInnerNode *tinode_init(char c) {
|
||||
TrieInnerNode *node = calloc(1, sizeof(TrieInnerNode));
|
||||
node->key = c;
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
/**
|
||||
* Allocate and initialize a new TrieNode.
|
||||
*
|
||||
* @return pointer to newly allocated struct
|
||||
*/
|
||||
TrieNode *tnode_init() {
|
||||
TrieNode *node = malloc(sizeof(TrieNode));
|
||||
|
||||
node->tree_size = 0;
|
||||
node->string_len = 0;
|
||||
node->represents = false;
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
/**
|
||||
* Free a TrieInnerNode and its underlying tree structure. This should
|
||||
* usually only be called on the root of a binary tree to free the entire
|
||||
* structure.
|
||||
*
|
||||
* @param node node whose tree to free
|
||||
*/
|
||||
void tinode_free_cascade(TrieInnerNode *node) {
|
||||
if (node->left != NULL) {
|
||||
tinode_free_cascade(node->left);
|
||||
}
|
||||
|
||||
if (node->right != NULL) {
|
||||
tinode_free_cascade(node->right);
|
||||
}
|
||||
|
||||
if (node->next != NULL) {
|
||||
tnode_free(node->next);
|
||||
}
|
||||
|
||||
free(node);
|
||||
}
|
||||
|
||||
/**
|
||||
* Free a TrieNode and its underlying tree structure.
|
||||
*
|
||||
* @param node node to free
|
||||
*/
|
||||
void tnode_free(TrieNode *node) {
|
||||
if (node->tree_size > 0) {
|
||||
tinode_free_cascade(node->tree);
|
||||
}
|
||||
|
||||
// TODO properly free entry
|
||||
/* if (node->payload != NULL) { */
|
||||
/* free(node->payload); */
|
||||
/* } */
|
||||
|
||||
free(node);
|
||||
}
|
||||
|
||||
/**
|
||||
* This function performs a lookup in the underlying binary tree of the given
|
||||
* TrieNode. If found, the return value is a pointer to the memory
|
||||
* location where the TrieInnerNode representing the given character
|
||||
* stores its `next` field. If not found, the return value is NULL, unless
|
||||
* `create` is true.
|
||||
*
|
||||
* NOTE: a non-NULL return value does not mean that the dereferenced value is
|
||||
* also not NULL. In particular, if `create` is set to true and the function had
|
||||
* to create the new node, the dereferenced value will always be NULL.
|
||||
*
|
||||
* @param node node to perform lookup in. If node is a full leaf, the return
|
||||
* value will always be NULL, regardless of the value of create.
|
||||
* @param create whether to create the TrieInnerNode if it isn't present
|
||||
* yet. If this is set to true, the function will never return NULL unless the
|
||||
* node represents a leaf with a string, because the struct and therefore the
|
||||
* address is created if it doesn't exist yet.
|
||||
*/
|
||||
TrieNode **tnode_search(TrieNode *node, const char c, bool create) {
|
||||
// It can happen that the node has no initialized root yet
|
||||
if (node->tree_size == 0) {
|
||||
if (create) {
|
||||
node->tree_size++;
|
||||
node->tree = tinode_init(c);
|
||||
|
||||
return &node->tree->next;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
TrieInnerNode *parent = node->tree;
|
||||
TrieInnerNode *child;
|
||||
|
||||
// Iterate through the tree until we either find the character or realize it's
|
||||
// not present in the tree
|
||||
// FIXME don't use while (1)
|
||||
while (1) {
|
||||
if (parent->key == c) {
|
||||
return &parent->next;
|
||||
} else if (c < parent->key) {
|
||||
child = parent->left;
|
||||
} else {
|
||||
child = parent->right;
|
||||
}
|
||||
|
||||
if (child == NULL) {
|
||||
break;
|
||||
}
|
||||
|
||||
parent = child;
|
||||
};
|
||||
|
||||
// child is NULL, meaning the character isn't in the binary tree yet.
|
||||
|
||||
// If create is true, we create the new node so that we can still return a
|
||||
// non-NULL pointer.
|
||||
if (create) {
|
||||
TrieInnerNode *new_node = tinode_init(c);
|
||||
|
||||
if (c < parent->key) {
|
||||
parent->left = new_node;
|
||||
} else {
|
||||
parent->right = new_node;
|
||||
}
|
||||
|
||||
node->tree_size++;
|
||||
|
||||
return &new_node->next;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* Split a remaining string leaf node in two. This function assumes it receives
|
||||
* a full leaf as its input.
|
||||
*
|
||||
* @param node node to split
|
||||
*/
|
||||
/* void tnode_split(TrieNode *node) { */
|
||||
/* TrieNode *new_node = tnode_init(); */
|
||||
/* char key = node->ptr.string[0]; */
|
||||
|
||||
/* // There's a chance the remaining string was only 1 character, meaning the
|
||||
* new */
|
||||
/* // node doesn't have to store a string */
|
||||
/* if (node->ptr.string[1] != DELIMITER) { */
|
||||
/* tnode_set_string(new_node, node->ptr.string + 1); */
|
||||
/* } else { */
|
||||
/* new_node->type = 1; */
|
||||
/* } */
|
||||
|
||||
/* new_node->entry = node->entry; */
|
||||
|
||||
/* node->type = 0; */
|
||||
/* node->size = 0; */
|
||||
/* node->entry = NULL; */
|
||||
|
||||
/* free(node->ptr.string); */
|
||||
/* node->ptr.string = NULL; */
|
||||
|
||||
/* // Initialize node's binary tree with the correct character */
|
||||
/* TrieNode **node_ptr = tnode_search(node, key, true); */
|
||||
/* *node_ptr = new_node; */
|
||||
/* } */
|
||||
|
||||
/*
|
||||
* Remove the given character from a TrieInnerNode's subtree. The
|
||||
* function assumes the character is indeed in the subtree.
|
||||
*/
|
||||
void tinode_remove(TrieInnerNode *node, const char c) {
|
||||
TrieInnerNode **to_remove_ptr = &node;
|
||||
|
||||
// We use pointers to pointers here so we can later free the removed node
|
||||
// without having to know what its parent is
|
||||
while ((*to_remove_ptr)->key != c) {
|
||||
to_remove_ptr = (c < (*to_remove_ptr)->key) ? &(*to_remove_ptr)->left
|
||||
: &(*to_remove_ptr)->right;
|
||||
};
|
||||
|
||||
// If the node isn't a leaf, we have to replace it with another
|
||||
if ((*to_remove_ptr)->left != NULL || (*to_remove_ptr)->right != NULL) {
|
||||
TrieInnerNode *to_replace = *to_remove_ptr;
|
||||
|
||||
// Replace with its only right child
|
||||
if (to_replace->left == NULL) {
|
||||
TrieInnerNode *to_remove = to_replace->right;
|
||||
|
||||
to_replace->key = to_remove->key;
|
||||
to_replace->next = to_remove->next;
|
||||
to_replace->left = to_remove->left;
|
||||
to_replace->right = to_remove->right;
|
||||
|
||||
free(to_remove);
|
||||
}
|
||||
// Replace with its only left child
|
||||
else if (to_replace->right == NULL) {
|
||||
TrieInnerNode *to_remove = to_replace->left;
|
||||
|
||||
to_replace->key = to_remove->key;
|
||||
to_replace->next = to_remove->next;
|
||||
to_replace->left = to_remove->left;
|
||||
to_replace->right = to_remove->right;
|
||||
|
||||
free(to_remove);
|
||||
}
|
||||
// Node has two children, so replace with successor
|
||||
else {
|
||||
TrieInnerNode *to_remove_parent = to_replace;
|
||||
TrieInnerNode *to_remove = to_replace->right;
|
||||
|
||||
while (to_remove->left != NULL) {
|
||||
to_remove_parent = to_remove;
|
||||
to_remove = to_remove->left;
|
||||
}
|
||||
|
||||
to_replace->key = to_remove->key;
|
||||
to_replace->next = to_remove->next;
|
||||
|
||||
if (to_remove_parent != to_replace) {
|
||||
to_remove_parent->left = to_remove->right;
|
||||
} else {
|
||||
to_remove_parent->right = to_remove->right;
|
||||
}
|
||||
|
||||
free(to_remove);
|
||||
}
|
||||
}
|
||||
// We're the leaf, so we free ourselves
|
||||
else {
|
||||
free(*to_remove_ptr);
|
||||
*to_remove_ptr = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove the given character from a TrieNode, respecting the rules
|
||||
* of a binary search tree. This function assumes the character is in the search
|
||||
* tree.
|
||||
*
|
||||
* @param node node to remove character from
|
||||
* @param c character to remove
|
||||
*/
|
||||
void tnode_remove(TrieNode *node, const char c) {
|
||||
tinode_remove(node->tree, c);
|
||||
|
||||
node->tree_size--;
|
||||
}
|
||||
|
|
@ -1,53 +0,0 @@
|
|||
#include <stdint.h>
|
||||
|
||||
#include "trie.h"
|
||||
|
||||
/**
|
||||
* Represents a node of the binary tree contained within each non-leaf
|
||||
* TrieNode.
|
||||
*/
|
||||
typedef struct tinode {
|
||||
struct tinode *left;
|
||||
struct tinode *right;
|
||||
struct tnode *next;
|
||||
char key;
|
||||
} TrieInnerNode;
|
||||
|
||||
/**
|
||||
* Represents a node inside a Trie. A node can be in one of three states:
|
||||
* - Internal node: a node that's part of a path to a leaf node. This node will
|
||||
* always have a size greater than one, and an initialized root.
|
||||
* - Leaf: a node solely used to represent a string ending there. Its size is 0,
|
||||
* its ptr is unitialized and represents is true.
|
||||
* - Full leaf: a leaf node that contains a string. This occurs when a string is
|
||||
* added whose path is not fully in the tree yet, causing its remaining suffix
|
||||
* to be stored as a single node. Its size will be zero, represents its true,
|
||||
* and its string pointer is initialized.
|
||||
*/
|
||||
typedef struct tnode {
|
||||
Entry *entry;
|
||||
|
||||
TrieInnerNode *tree;
|
||||
uint8_t tree_size;
|
||||
|
||||
// Skips are at most TRIE_MAX_SKIP_SIZE characters, and are stored in the
|
||||
// nodes
|
||||
char string[TRIE_MAX_SKIP_SIZE];
|
||||
uint8_t string_len;
|
||||
|
||||
bool represents;
|
||||
} TrieNode;
|
||||
|
||||
TrieInnerNode *tinode_init(char c);
|
||||
|
||||
TrieNode *tnode_init();
|
||||
|
||||
void tinode_free_cascade(TrieInnerNode *node);
|
||||
|
||||
void tnode_free(TrieNode *node);
|
||||
|
||||
TrieNode **tnode_search(TrieNode *node, const char c, bool create);
|
||||
|
||||
void tinode_remove(TrieInnerNode *node, const char c);
|
||||
|
||||
void tnode_remove(TrieNode *node, const char c);
|
||||
Loading…
Add table
Add a link
Reference in a new issue