tHTableData deleteNode(tHTableKey key) {
tHTableNode *ukAct, *ukPrev = NULL;
tHTableIndex index;
tHTableData data;
/* nejdříve spočítáme index, kde začíná lin. seznam synonym */
index = hashFn(key);
ukAct = hashTable[index];
while (ukAct && !compEQ(ukAct->key, key)) {
ukPrev = ukAct;
ukAct = ukAct->next;
}
if (ukAct == NULL)
return -1; //hledaný klíč nebyl nalezen
if (ukPrev == NULL) /* mažeme první uzel seznamu synonym ? */
hashTable[index] = ukAct->next; /* ano: nastav ukazatel na první prvek na další za mazaným */
else
/* ne: propoj prvek před mazaným s prvkem za mazaným */
ukPrev->next = ukAct->next;
data = ukAct->data;
free(ukAct);
return data;
}
tHTableData findNode(tHTableKey key) {
tHTableNode *uk;
uk = hashTable[hashFn(key)];
while (uk && !compEQ(uk->key, key))
uk = uk->next;
return uk->data;
}
/**
*
* Find item containing the specified primary_key. Returns the data
* that it points to (not the item itself).
*
*/
ListData *findList(List *l, TYPE_LIST_PRIMARY_KEY primary_key){
ListItem *current;
current = l->first;
while (current != NULL){
if (compEQ(current->data->primary_key, primary_key)) return (current->data);
current = current->next;
}
return (NULL);
}
RBData *findNode(RBTree *tree, TYPE_RBTREE_PRIMARY_KEY primary_key) {
Node *current = tree->root;
while(current != NIL)
if(compEQ(primary_key, current->data->primary_key))
return (current->data);
else
current = compLT(primary_key, current->data->primary_key) ?
current->left : current->right;
return NULL;
}
Node *findNode(RBTree *tree, TYPEKEY key) {
Node *current = tree->root;
while(current != NIL)
if(compEQ(key, current->data->key))
return (current);
else
current = compLT(key, current->data->key) ?
current->left : current->right;
return NULL;
}
// find key
NodeType *rbtFind(RBTreeType *tree, KeyType key)
{
NodeType **root = &tree->root;
NodeType *current;
current = *root;
while(current != SENTINEL) {
if(compEQ(key, current->key)) {
return current;
} else {
current = compLT (key, current->key) ?
current->left : current->right;
}
}
return NULL;
}
Node *findNode(T data) {
/*******************************
* find node containing data *
*******************************/
Node *current = root;
while(current != NIL)
if(compEQ(data, current->data))
return (current);
else
current = compLT (data, current->data) ?
current->left : current->right;
return(0);
}
ListData *findList(List *l, TYPEKEY key)
{
ListItem *current;
current = l->first;
while (current != NULL)
{
if (compEQ(current->data->key, key))
return (current->data);
current = current->next;
}
return (NULL);
}
void insertNode(RBTree *tree, RBData *data) {
Node *current, *parent, *x;
/* Find where node belongs */
current = tree->root;
parent = 0;
while (current != NIL) {
if (compEQ(data->primary_key, current->data->primary_key)) {
printf("insertNode: trying to insert but primary key is already in tree.\n");
exit(1);
}
parent = current;
current = compLT(data->primary_key, current->data->primary_key) ?
current->left : current->right;
}
/* setup new node */
if ((x = malloc (sizeof(*x))) == 0) {
printf ("insufficient memory (insertNode)\n");
exit(1);
}
/* Note that the data is not copied. Just the pointer
is assigned. This means that the pointer to the
data should not be overwritten after calling this
function. */
x->data = data;
/* Copy remaining data */
x->parent = parent;
x->left = NIL;
x->right = NIL;
x->color = RED;
/* Insert node in tree */
if(parent) {
if(compLT(data->primary_key, parent->data->primary_key))
parent->left = x;
else
parent->right = x;
} else {
tree->root = x;
}
insertFixup(tree, x);
}
statusEnum insert(keyType key, recType *rec) {
int i, newLevel;
nodeType *update[MAXLEVEL+1];
nodeType *x;
/***********************************************
* allocate node for data and insert in list *
***********************************************/
/* find where key belongs */
x = list.hdr;
for (i = list.listLevel; i >= 0; i--) {
while (x->forward[i] != NIL
&& compLT(x->forward[i]->key, key))
x = x->forward[i];
update[i] = x;
}
x = x->forward[0];
if (x != NIL && compEQ(x->key, key))
return STATUS_DUPLICATE_KEY;
/* determine level */
for (
newLevel = 0;
rand() < RAND_MAX/2 && newLevel < MAXLEVEL;
newLevel++);
if (newLevel > list.listLevel) {
for (i = list.listLevel + 1; i <= newLevel; i++)
update[i] = NIL;
list.listLevel = newLevel;
}
/* make new node */
if ((x = malloc(sizeof(nodeType) + newLevel*sizeof(nodeType *))) == 0)
return STATUS_MEM_EXHAUSTED;
x->key = key;
x->rec = *rec;
/* update forward links */
for (i = 0; i <= newLevel; i++) {
x->forward[i] = update[i]->forward[i];
update[i]->forward[i] = x;
}
return STATUS_OK;
}
// insert new node (no duplicates allowed)
RbtStatus rbtInsert(RBTreeType *tree, KeyType key, ValType val)
{
NodeType **root = &tree->root;
NodeType *current, *parent, *x;
// allocate node for data and insert in tree
// find future parent
current = *root;
parent = 0;
while (current != SENTINEL) {
if (compEQ(key, current->key))
return RBT_STATUS_DUPLICATE_KEY;
parent = current;
current = compLT(key, current->key) ?
current->left : current->right;
}
// setup new node
if ((x = malloc (sizeof(*x))) == 0)
return RBT_STATUS_MEM_EXHAUSTED;
x->parent = parent;
x->left = SENTINEL;
x->right = SENTINEL;
x->color = RED;
x->key = key;
x->val = val;
// insert node in tree
if(parent) {
if(compLT(key, parent->key))
parent->left = x;
else
parent->right = x;
} else {
*root = x;
}
insertFixup(root, x, SENTINEL);
return RBT_STATUS_OK;
}
rbt_node* rbt_insert(T key, LRU_elem *associated_LRU_elem, rbt_node **root) {
rbt_node *current, *parent, *x;
/***********************************************
* allocate node for data and insert in tree *
***********************************************/
/* find where node belongs */
current = *root;
parent = 0;
while (current != NIL) {
if (compEQ(key, current->key)) return (current);
parent = current;
current = compLT(key, current->key) ?
current->left : current->right;
}
/* setup new node */
if ((x = malloc (sizeof(*x))) == 0) {
printf ("insufficient memory (insertNode)\n");
exit(1);
}
x->key = key;
x->parent = parent;
x->left = NIL;
x->right = NIL;
x->color = RED;
x->associated_LRU_elem = associated_LRU_elem;
/* insert node in tree */
if(parent) {
if(compLT(key, parent->key))
parent->left = x;
else
parent->right = x;
} else {
*root = x;
}
insertFixup(x, root);
return(x);
}
Node *insertNode(T data) {
Node *current, *parent, *x;
/***********************************************
* allocate node for data and insert in tree *
***********************************************/
/* find where node belongs */
current = root;
parent = 0;
while (current != NIL) {
if (compEQ(data, current->data)) return (current);
parent = current;
current = compLT(data, current->data) ?
current->left : current->right;
}
/* setup new node */
if ((x = malloc (sizeof(*x))) == 0) {
printf ("insufficient memory (insertNode)\n");
exit(1);
}
x->data = data;
x->parent = parent;
x->left = NIL;
x->right = NIL;
x->color = RED;
/* insert node in tree */
if(parent) {
if(compLT(data, parent->data))
parent->left = x;
else
parent->right = x;
} else {
root = x;
}
insertFixup(x);
return(x);
}
//-----------------------------------------------------------------------------
/// find node containing data and place to insert of not found
/// \param[in] d -- data to find
/// \param[in] p_root -- refers to the tree root
/// \param[out]p_insert_parent -- where to insert the new node if not found:
/// - *p_insert_parent := parent
/// - if node found, this ptr is unchanged!
/// - if no parent (empty tree) 0 is returned in this ptr
/// this value should be passed to insertNodeToParent() function
/// \return ptr to node found, or 0 if not found.
//-----------------------------------------------------------------------------
Node *findNode(T d, Node**p_root, Node**p_insert_parent)
{
if(*p_root)
{ Node *current = *p_root;
Node *parent = 0;
while(current != NIL)
if(compEQ(d, current->node_data))
return (current);
else
{ parent=current;
current = compLT (d, current->node_data) ? current->left
: current->right;
}
if(p_insert_parent) *p_insert_parent = parent;
return(0);
}
else
{ if(p_insert_parent) *p_insert_parent = 0;
return(0);
}
}
Node * insertNode(T data) {
Node * current, * parent, * x;
/***********************************************
* allocate node for data and insert in tree *
***********************************************/
/* find where node belongs */
current = root;
parent = 0;
while (current != NIL) {
if (compEQ(data, current->data)) {
++current->count;
return (current);
}
parent = current;
current = compLT(data, current->data) ? current->left : current->right;
}
/* setup new node */
if ((x = malloc (sizeof(*x))) == 0)
err(EMEM);
x->data = data;
x->parent = parent;
x->left = NIL;
x->right = NIL;
x->color = RED;
x->count = 1;
/* insert node in tree */
if(parent) {
if(compLT(data, parent->data))
parent->left = x;
else
parent->right = x;
} else
root = x;
insertFixup(x);
return(x);
}
