void btree_test() { struct btree *node1 = btree_create(NULL, TYPE_INT, 1); struct btree *node2 = btree_create(NULL, TYPE_INT, 2); struct btree *node3 = btree_create(NULL, TYPE_INT, 3); struct btree *node4 = btree_create(NULL, TYPE_INT, 4); struct btree *node5 = btree_create(NULL, TYPE_INT, 5); struct btree *node6 = btree_create(NULL, TYPE_INT, 6); struct btree *node7 = btree_create(NULL, TYPE_INT, 7); struct btree *node8 = btree_create(NULL, TYPE_INT, 8); node1->left = node2; node1->right = node3; node2->left = node4; node2->right = node5; node3->left = node6; node3->right = node7; node4->left = node8; fprintf(stdout, "preorder:\n"); btree_preorder(node1); fprintf(stdout, "postorder:\n"); btree_postorder(node1); fprintf(stdout, "inorder:\n"); btree_inorder(node1); fprintf(stdout, "btree_search(node5, node8) = %d\n", btree_search(node5, node8)); fprintf(stdout, "btree_search(node4, node8) = %d\n", btree_search(node4, node8)); btree_destroy(node1); }
/** * @brief test case for random number insert, search and delete. */ void testcase_for_random() { TREE* T = btree_create(); int i = 0, n = 100; int _t = 0; srand(time(NULL)); for (i = 0; i < n; i ++) { _t = rand() % n; printf("btree_insert(T, %d) = %d\n", _t, btree_insert(T, _t)); } for (i = 0; i < n; i ++) { _t = rand() % n; printf("btree_search(T, %d) = %d\n", _t, btree_search(T, _t)); } printf("btree_traveral: "); btree_traveral(T, printout_node); printf("\n"); for (i = 0; i < n; i ++) { _t = rand() % n; printf("btree_delete(T, %d) = %d\n", _t, btree_delete(T, _t)); } printf("btree_traveral: "); btree_traveral(T, printout_node); printf("\n"); btree_destory(T); }
void *acl_btree_remove(ACL_BTREE *tree, unsigned int key) { const char *myname = "acl_btree_remove"; BTREE_NODE *x; void *data; btree_validate(tree); x = btree_search(tree->root, key); if (x == NULL) { acl_msg_error("%s(%d): Item not on tree - key %u\n", myname, __LINE__, key); return (NULL); } /* Note value that gets freed is not necessarily the the same * as node that gets removed from tree since there is an * optimization to avoid pointer updates in tree which means * sometimes we just copy key and data from one node to another. */ data = x->data; x = btree_delete_node(tree, x); acl_slice_free2(tree->slice, x); return (data); }
void * btree_get_data(btree_t *root, int key) { btree_t *node= NULL; node = btree_search(root, key); return (node && node->data) ? node->data : NULL; }
int btree_remove(btree_t *tree, uint32_t key, void **data) { btree_node_t *x; btree_validate(tree); x = btree_search(tree->root, key); if (x == NULL) { debug_msg("Item not on tree - key %ul\n", key); *data = NULL; return FALSE; } /* Note value that gets freed is not necessarily the the same * as node that gets removed from tree since there is an * optimization to avoid pointer updates in tree which means * sometimes we just copy key and data from one node to * another. */ *data = x->data; x = btree_delete_node(tree, x); xfree(x); return TRUE; }
/* name here includes entity qual ... &/% */ Entity* get_ref_entity_def(Ctl* ctl, int parameter_entity, XString name, int strip) { XString name1, dummystring; Node *defnode; LookupType lu_type; XmlBTree *tree; BTreeCtl *treectl; uint16 index; lclmemcpy(&name1, &name, sizeof(XString)); if(strip) { name1.loc += 1 + ctl->is_double; name1.len -= 1 +ctl->is_double; } treectl = &ctl->btree_ctl; tree = treectl->btree; if(parameter_entity) lu_type = lu_pe; else lu_type = lu_ge; index = btree_search(ctl, lu_type, &name1, &dummystring, 0); if(index == 0) return 0; defnode = tree[index].definition; assert(defnode->node_type == ENTITYDECL); return ( (Entity*)defnode->internal_rep); }
int btree_remove(node_bt *list, node_bt *node, int(*func)(void*,void*), void *key) { node_bt *parent; node_bt **buff; if (list == node) { if (remove_root(list) == 0) return 0; else return -1; } parent = btree_search(list, key, func); if (parent->left == node) { buff = &parent->left; } else { buff = &parent->right; } remove_not_root(node, buff); return 0; }
/** * @brief test case for single insert, search and delete method. */ void testcase_for_single() { TREE* T = btree_create(); printf("btree_insert(T, 32) = %d\n", btree_insert(T, 32)); printf("btree_search(T, 32) = %d\n", btree_search(T, 32)); printf("btree_delete(T, 32) = %d\n", btree_delete(T, 32)); printf("btree_search(T, 32) = %d\n", btree_search(T, 32)); printf("btree_traveral: "); btree_traveral(T, printout_node); printf("\n"); btree_destory(T); }
R_API void *btree_get(struct btree_node *proot, void *x, BTREE_CMP(cmp)) { struct btree_node *p = btree_search (proot, x, cmp, 0); if (p) { p->hits++; return p->data; } return NULL; }
R_API void *btree_search(struct btree_node *root, void *x, BTREE_CMP(cmp), int parent) { struct btree_node *p = NULL; if (root!=NULL) { if (cmp (x, root->data)<0) p = btree_search (root->left, x, cmp, parent); else if (cmp(x, root->data)>0) p = btree_search (root->right, x, cmp, parent); else p = root; } /* node found */ if (p) { if (parent) return root; return p; } return NULL; }
R_API int btree_del(struct btree_node *proot, void *x, BTREE_CMP(cmp), BTREE_DEL(del)) { struct btree_node *p = btree_search (proot, x, cmp, 1); if (p) { // p->right = btree_remove (p->left, del); return R_TRUE; } return R_FALSE; }
/** * @brief B tree delete method. * * @param T B tree. * @param k the element to delete. * * @return return 1 means delete success, otherwise return 0 means not delete it * as the element k is not include in the B tree. */ PUBLIC int btree_delete(TREE* T, ELEMENT k) { if (!btree_search(T, k)) { return 0; } _btree_delete(T->root, k); NODE* r = T->root; if (0 == r->n) { T->root = r->c[0]; _btree_free_node(r); } return 1; }
tnode *btree_search(char *key, tnode *t){ int cmp = 0; tnode *result = NULL; if(t == NULL){ result = NULL; }else{ cmp = strcmp(t->key, key); if(cmp == 0){ result = t; }else if(cmp < 0){ result = btree_search(key, t->left); }else{ result = btree_search(key, t->right); } } return result; }
R_API bool btree_del(struct btree_node *proot, void *x, BTREE_CMP(cmp), BTREE_DEL(del)) { struct btree_node *p = btree_search (proot, x, cmp, 1); if (p) { // p->right = btree_remove (p->left, del); p->left = NULL; return true; } return false; }
String btree_search(String key, Btree t) { if (btree_isempty(t)) return NULL; else if (strcmp(key, t->key) < 0){ if (btree_isempty(t->left)) return NULL; else return btree_search(key, t->left); } else if (strcmp(key, t->key) > 0){ if (btree_isempty(t->right)) return NULL; else return btree_search(key, t->right); } else return t->value; }
int main(int argc, char *argv[]) { btree_tree *tmp; FILE *f; char urlBuffer[2048], *data; uint64_t id; uint64_t i = 0, found = 0; int error; tmp = btree_open("tree2.mmap", &error); if (!tmp) { printf("Couldn't open tree, errno %d.\n", error); exit(1); } if (argc < 2) { printf("Please pass a text file via argv to search for in the btree\n"); exit(1); } f = fopen(argv[1], "r"); if (!f) { printf("Couldn't open file %s, errno %d.\n", argv[1], errno); exit(1); } while (!feof(f)) { fgets(urlBuffer, 2048, f); data = strchr(urlBuffer, ' '); if (data) { data++; data[-1] = '\0'; id = atoll(urlBuffer); found += btree_search(tmp, tmp->root, id); found += btree_search(tmp, tmp->root, id + 1); i++; } } printf("%lu %lu\n", found, i); btree_close(tmp); return 0; }
void *acl_btree_find(ACL_BTREE *tree, unsigned int key) { BTREE_NODE *x; btree_validate(tree); x = btree_search(tree->root, key); if (x != NULL) { return (x->data); } return (NULL); }
int btree_find(btree_t *tree, uint32_t key, void **d) { btree_node_t *x; btree_validate(tree); x = btree_search(tree->root, key); if (x != NULL) { *d = x->data; return TRUE; } return FALSE; }
int main() { Btree t = (struct tnode *)malloc(sizeof(struct tnode)); t = btree_empty(); String s = (char *)malloc(50); String a = (char *)malloc(50); String b = (char *)malloc(50); while (scanf("%49s ", s) != EOF){ if (strcmp(s, "insert") == 0){ scanf("%49s ", a); scanf("%49s\n", b); t = btree_insert(a, b, t); } else if (strcmp(s, "delete") == 0){ scanf("%49s\n", a); t = btree_delete(a, t); } else if (strcmp(s, "search") == 0){ scanf("%49s\n", a); if (btree_search(a, t) == NULL) printf("(not found)\n"); else printf("%s\n", (btree_search(a, t))); } else if (strcmp(s, "quit") == 0) break; else{ printf("(unknown command)\n"); } } free_btree(t); free(a); free(b); free(s); return 0; }
void updateTree(BTree* tree, char* word, int pos, char* urlDoc) { BTreeKey* existingKey = btree_search(tree->root, word); if (existingKey) { addPositionVector(existingKey->mInfo, urlDoc, pos); free(word); } else { Vector* bkey_info = vector_newVector(); addPositionVector(bkey_info, urlDoc, pos); BTreeKey* bkey = btree_newBTreeKey(word, bkey_info); btree_insert(tree, tree->root, bkey); } }
Node *btree_get_def(Ctl *ctl, LookupType lu_type, XString *name) { XmlBTree *tree; BTreeCtl *treectl; XString dummy_value; uint16 index; treectl = &ctl->btree_ctl; tree = treectl->btree; index = btree_search(ctl, lu_type, name, &dummy_value, 0); if(index == 0) return NULL; return(tree[index].definition); }
/** * @brief B tree insert method. * * @param T B tree. * @param k the element to insert. * * @return return 1 means insert success, otherwise return 0 means not insert it * as the element is already include in the B tree. */ PUBLIC int btree_insert(TREE* T, ELEMENT k) { if (btree_search(T, k)) { return 0; } NODE* r = T->root; if (FULL_KEY_COUNT == r->n) { NODE* s = _btree_allocate_node(); T->root = s; s->leaf = FALSE; s->n = 0; s->c[0] = r; _btree_split_child(s, 0); _btree_insert_nonfull(s, k); } else { _btree_insert_nonfull(r, k); } return 1; }
void * h_table_find( h_table_t *table, char *key ) { int index; index = btree_search( table->tree, key ); if( index != -1 ) { return table->data_arr[ index ]; } else { return NULL; } }
static BI_DATA * find_elapsed(const char *txt) { BI_DATA *result = 0; char temp[80]; char *s = strchr(mktrimmed(strcpy(temp, txt)), L_PAREN); if (s != 0) *s = EOS; if (*temp != EOS) { if ((result = btree_search(&elapsed_tree, temp)) == 0) { BI_DATA data; memset(&data, 0, sizeof(data)); data.bi_key = temp; result = btree_insert(&elapsed_tree, &data); } } return result; }
BTreeNode * btree_search( BTreeNode * node, Key k, int * index ) { int i = 0; while( i < node->n && k > node->keys[i] ) ++i; if( i < node->n && k == node->keys[i] ) { *index = i; return node; } else if( node->leaf ) { return NULL; } else { return btree_search(node->children[i], k, index ); } }
int main(){ char command[100]; char word[100]; char tango[100]; tnode *tree = NULL; tnode *temp = NULL; while(1){ scanf("%s", command); if(strcmp(command, "insert") == 0){ scanf("%s %s", word, tango); temp = btree_insert(word, tango, tree); if(tree == NULL){ tree = temp; } }else if(strcmp(command, "delete") == 0){ scanf("%s", word); temp = btree_delete(word, tree); if(temp == tree->left){ tree = tree->left; }else if(temp == tree->right){ tree = tree->right; } }else if(strcmp(command, "search") == 0){ scanf("%s", word); temp = btree_search(word, tree); if(temp == NULL){ printf("(not found)\n"); }else{ printf("%s\n", temp->value); } }else if(strcmp(command, "quit") == 0){ break; }else{ printf("ERROR\n"); } } btree_destroy(tree); return 0; }
int btree_get_next_key(btree_t *tree, uint32_t cur_key, uint32_t *next_key) { btree_node_t *x; btree_validate(tree); x = btree_search(tree->root, cur_key); if (x == NULL) { return FALSE; } x = btree_successor(x); if (x == NULL) { return FALSE; } *next_key = x->key; return TRUE; }
int acl_btree_get_next_key(ACL_BTREE *tree, unsigned int cur_key, unsigned int *next_key) { BTREE_NODE *x; btree_validate(tree); x = btree_search(tree->root, cur_key); if (x == NULL) { return (-1); } x = btree_successor(x); if (x == NULL) { return (-1); } *next_key = x->key; return (0); }
int binode_cache_find (uint64_t key, bt_key_val *temp_binode) { clock_t start, end; int ret = 0; bt_key_val kv; LINKED *temp; #ifdef DEBUG_FUXEXMP fprintf(stderr, "binode_cache_find: key = %llx\n", key); #ifdef DEBUG print_subtree(block_inode_tree, block_inode_tree->root); #endif #endif kv = btree_search(block_inode_tree,key); if (kv.val != 0) { *temp_binode = kv; ret = SUCCESS; temp=kv.pt; if(temp!=binode_list) { temp->prev->next=temp->next; temp->next->prev=temp->prev; temp->prev=binode_list->prev; temp->next=binode_list; binode_list->prev=temp; binode_list=temp; } } else { ret = FAILURE; } return ret; }
int memory_cache_find (uint64_t hash_key, bt_key_val *temp_memory) { clock_t start, end; int ret = 0; bt_key_val kv; LINKED *temp; kv = btree_search(memory_tree,hash_key); if (kv.val != 0) { *temp_memory = kv; ret = SUCCESS; temp=kv.pt; if(temp!=memory_list) { temp->prev->next=temp->next; temp->next->prev=temp->prev; temp->prev=memory_list->prev; temp->next=memory_list; memory_list->prev=temp; memory_list=temp; } } else { ret = FAILURE; } return ret; }