bool RBTreeIteratorNext(RBTreeIterator *iter, void **key, void **value)
{
if (Peek_(iter, key, value))
{
iter->curr = Next_(iter->tree, iter->curr);
return true;
}
else
{
return false;
}
}
static char *find_owner(int uid)
{ OwnerDetails *node;
char *temp;
for (node = Head_(OwnerDetails, OwnerList);
!EndOfList_(node);
node = Next_(OwnerDetails, node))
if (node->Uid eq uid)
return(node->Name);
node = New(OwnerDetails);
if (node eq Null(OwnerDetails))
return("<unknown>");
node->Uid = uid;
temp = (char *) RmWhoIs(uid);
if (temp eq Null(char))
strcpy(node->Name, "<unknown>");
else
bool RBTreeRemove(RBTree *tree, const void *key)
{
assert(!tree->nil->red);
RBNode *z = Get_(tree, key);
if (z == tree->nil)
{
return false;
}
RBNode *y = ((z->left == tree->nil) || (z->right == tree->nil)) ? z : Next_(tree, z);
RBNode *x = (y->left == tree->nil) ? y->right : y->left;
x->parent = y->parent;
if (tree->root == x->parent)
{
tree->root->left = x;
}
else
{
if (y == y->parent->left)
{
y->parent->left = x;
}
else
{
y->parent->right = x;
}
}
if (z != y)
{
assert(y != tree->nil);
assert(!tree->nil->red);
if (!y->red)
{
RemoveFix_(tree, x);
}
y->left = z->left;
y->right = z->right;
y->parent = z->parent;
y->red = z->red;
z->left->parent = y;
z->right->parent = y;
if (z == z->parent->left)
{
z->parent->left = y;
}
else
{
z->parent->right = y;
}
NodeDestroy_(tree, z);
}
else
{
if (!y->red)
{
RemoveFix_(tree, x);
}
NodeDestroy_(tree, y);
}
assert(!tree->nil->red);
tree->size--;
return true;
}
RBTree *RBTreeCopy(const RBTree *tree, RBTreePredicate *filter, void *user_data)
{
RBNode **nodes = xmalloc(tree->size * sizeof(RBNode *));
size_t node_count = 0;
{
RBTreeIterator *iter = NULL;
for (iter = RBTreeIteratorNew(tree); iter->curr != iter->tree->nil; iter->curr = Next_(iter->tree, iter->curr))
{
if (!filter || filter(iter->curr->key, iter->curr->value, user_data))
{
nodes[node_count] = iter->curr;
node_count++;
}
}
RBTreeIteratorDestroy(iter);
}
RBTree *copy = RBTreeNew(tree->KeyCopy, tree->KeyCompare, tree->KeyDestroy,
tree->ValueCopy, tree->ValueCompare, tree->ValueDestroy);
RBNode *node = NULL;
// [0, 1, 2, 3, 4]
if ((node_count % 2) != 0)
{
node = nodes[node_count / 2];
RBTreePut(copy, node->key, node->value);
node_count--;
}
else
{
node = copy->root;
}
assert((node_count % 2) == 0);
// [0, 1, 2, 3]
for (size_t i = 0; i < (node_count / 2); i += 1)
{
node = nodes[(node_count / 2) + i];
RBTreePut(copy, node->key, node->value);
node = nodes[(node_count / 2) - i - 1];
RBTreePut(copy, node->key, node->value);
}
free(nodes);
VerifyTree_(copy);
return copy;
}
