int main() { tree_t *urls = tree_open(cmp_str, del_str); /*if(fetch_data(urls) < 0) { fprintf(stderr, "cannot fetch data\n"); exit(1); }*/ int min_len; min_len = load_urls("tree.db", urls); printf("min len is: %d\n", min_len); char *str = "http://metro.co.uk/2016/08/24/rapists-dad-threatened-to-kill-witness-with-rounders-bat-6087084/"; printf("%s exists? %s\n", str, tree_find(urls, str)==0 ? "yes":"no"); if(tree_find(urls, str) == 0) { tree_del(urls, str); } printf("%s exists? %s\n", str, tree_find(urls, str)==0 ? "yes":"no"); printf("tree height is: %d\n", urls->root->height); printf("root balance factor: %i", tree_node_bf(urls->root->rgt)); //save_urls(urls); tree_close(urls); return 0; }
void mncl_release_raw(MNCL_RAW *raw) { struct resmap_node seek, *found = NULL, *found2 = NULL; if (!raw) { return; } seek.resource = raw; found = (struct resmap_node *)tree_find(&reverse_map, (TREE_NODE *)&seek, ptrcmp); if (!found) { return; } printf("Mapped to %s...", found->resname); found2 = (struct resmap_node *)tree_find(&locked_resources, (TREE_NODE *)found, rescmp); if (found2) { --found2->refcount; if (!found2->refcount) { printf("freeing.\n"); tree_delete(&reverse_map, (TREE_NODE *)found); tree_delete(&locked_resources, (TREE_NODE *)found2); if (found2->resource->data) { free(found2->resource->data); free(found2->resource); free((void *)found2->resname); free((void *)found->resname); free(found); free(found2); } } else { printf("new refcount %d\n", found2->refcount); } } }
END_TEST START_TEST(test_tree_basics) { int seven = 7, one = 1, three = 3; ck_assert_int_eq(tree_size(tree), 0); ck_assert_int_eq(*(int *)tree_insert(tree, &seven, &seven), seven); ck_assert_int_eq(tree_size(tree), 1); ck_assert_int_eq(*(int *)tree_insert(tree, &one, &one), one); ck_assert_int_eq(tree_size(tree), 2); ck_assert_int_eq(*(int *)tree_insert(tree, &three, &three), three); ck_assert_int_eq(tree_size(tree), 3); ck_assert_int_eq(*(int *)tree_find(tree, &seven), seven); ck_assert_int_eq(*(int *)tree_find(tree, &one), one); ck_assert_int_eq(*(int *)tree_find(tree, &three), three); ck_assert_int_eq(*(int *)tree_delete(tree, &seven), seven); ck_assert_int_eq(tree_size(tree), 2); ck_assert_int_eq(*(int *)tree_delete(tree, &one), one); ck_assert_int_eq(tree_size(tree), 1); ck_assert_int_eq(*(int *)tree_delete(tree, &three), three); ck_assert_int_eq(tree_size(tree), 0); }
/* * Get elog status in the form of a TABLE */ TABLE elog_getstatus() { TABLE tab; TREE *row; int i; char *purl; /* create row */ row = tree_create(); tree_add(row, "severity", NULL); tree_add(row, "route", NULL); tree_add(row, "format", NULL); /* create table and add rows to it, made from the severity table */ tab = table_create_a(elog_colnames); for (i=0; i<ELOG_NSEVERITIES; i++) { tree_find(row, "severity"); tree_put(row, elog_sevstring[i]); tree_find(row, "route"); purl = xnstrdup( route_getpurl(elog_opendest[i].route) ); tree_put(row, purl); table_freeondestroy(tab, purl); tree_find(row, "format"); if (elog_opendest[i].format) tree_put(row, elog_opendest[i].format); else tree_put(row, ELOG_DEFFORMAT); table_addrow_alloc(tab, row); } tree_destroy(row); return tab; }
InputTree* tree_sibling_tree(TreeHist* treeh) { int pos = treeh->pos; int hp = treeh->hpos; InputTree* tr = NULL; //cerr << "tst " << pos << " " << hp << *treeh->tree << endl; if(pos > hp+1) tr = tree_find(treeh, -1); else if(pos < hp-1) tr = tree_find(treeh, 1); return tr; }
TreeNode tree_find(SearchTree tree, int data) { if (tree == NULL) { return NULL; } if (data < tree->data) { return tree_find(tree->left, data); } else if (data == tree->data) { return tree; } else { return tree_find(tree->right, data); } }
int main(int argc, char* argv[]) { //要求:对第i的页面的访问概率正比于1/sqrt(i+1) const int count = 30; const int tests = 10; TreeKeyType* sum = new TreeKeyType[count]; sum[0] = 1; //sum[0]=1 //sum[1]=sum[0]+1/sqrt(2) //sum[2]=sum[1]+1/sqrt(3) //... //sum[n-1]=sum[n-2]+1/sqrt(n) for (int i = 1; i < count; i++) { sum[i] = sum[i - 1] + (double)(1 / sqrt(i + 1)); } TreeKeyType MaxRandValue = sum[count - 1] - 0.00001; tree_node* search_node = tree_init(sum, count, 0); printf("Search node size: %d\n", tree_size(search_node) * sizeof(search_node)); printf("========== tree ==========\n"); tree_print(search_node); printf("========== find ==========\n"); srand((unsigned int)time(NULL)); for (int i = 0; i < tests; i++) { TreeKeyType rnd = rand() / double(RAND_MAX) * MaxRandValue; printf("key: %f, val: %d\n", rnd, tree_find(search_node, rnd)); } delete[] (sum); return 0; }
struct tree_node *tree_delete(struct tree_node **p_root, const struct bff_user_key *key) { /* First find the node, then delete it. */ struct tree_node *node = tree_find(*p_root, key); if (!node) { return NULL; } /* Fill in a lot of code here for tree delete. */ /* You have to set all of the links properly for all of the * cases: * node is a leaf node * node has just a left child * node has just a right child * node has two children */ /* Don't forget about the parent links. */ node->left = NULL; node->right = NULL; node->parent = NULL; return node; }
int main(){ BinTree *tree = tree_new(); /*tree_insert(tree, 5); tree_insert(tree, 7); tree_insert(tree, 3); tree_insert(tree, 8); tree_insert(tree, 1); tree_insert(tree, 0); tree_insert(tree, 2); tree_insert(tree, 6); tree_insert(tree, 4); //tree_remove(tree, 6); printf("%d\n", tree_height(tree)); printf("%d\n", tree_find(tree, 5)); tree_print(tree); */ int i; for (i = 0; i < TAM; i++) tree_insert(tree, i+1); //demora aprox 22 segundos a pesquisar todos os elementos da lista for (i = 0; i < TAM; i++) tree_find(tree, i); tree_destroy(tree); return 0; }
//根据val到二叉树中查找 bool tree_search(s_tree *tree, int val) { if (tree == null) { return false; } //如果二叉树没有根节点 if (tree->root == null) { //创建权值为val的根节点 s_node *p_new = (s_node *) malloc(sizeof(s_node)); p_new->weight = val; p_new->parent = null; p_new->left_child = null; p_new->right_child = null; tree->root = p_new; return true; } else { //递归查找 return tree_find(tree->root, val); } }
static inline ts_tree_node_t* ts_tree__find_node(ts_tree_t* ts_tree, uintptr_t key) { tree_node_t* tree_node = tree_find(&ts_tree->tree, key); if (tree_node == NULL) return NULL; return container_of(tree_node, ts_tree_node_t, tree_node); }
static inline Node *hashmap_find(var_p_t map, const char *key) { int length = strlen(key); int index = hashmap_get_hash(key, length) % map->v.m.size; Node **table = (Node **)map->v.m.map; Node *result = table[index]; if (result != NULL) { int r = tree_compare(key, length, result->key); if (r < 0 && result->left != NULL) { result = tree_find(&result->left, key, length); } else if (r > 0 && result->right != NULL) { result = tree_find(&result->right, key, length); } else if (r != 0) { result = NULL; } } return result; }
static int url_find(char *urltext) { int pos; if (tree_find((tree*)url_tree, urltext, (tree_cmp_func*)strcasecmp, nullptr, &pos)) return 1; return 0; }
InputTree* tree_2rel_tree(TreeHist* treeh) { //cerr << "t1r " << *treeh->tree << endl; int pos = treeh->pos; int hpos = treeh->hpos; if(pos == hpos || pos < hpos-1 || pos > hpos+1) return NULL; //cerr << "t2r " << *treeh->tree << endl; InputTree* sib; if(pos < hpos) { sib = tree_find(treeh, +1); int sibhp = headPosFromTree(sib); InputTree* sibch; if(sibhp > 0) { sibch = sib->subTrees().front(); } else if(sib->subTrees().size() < 2) return NULL; else { InputTreesIter iti = sib->subTrees().begin(); iti++; sibch = *iti; } return sibch; } else { sib = tree_find(treeh, -1); int sibhp = headPosFromTree(sib); InputTree* sibch; if(sibhp < sib->subTrees().size()-1) { sibch = sib->subTrees().back(); } else if(sib->subTrees().size() < 2) return NULL; else { InputTrees::reverse_iterator iti = sib->subTrees().rbegin(); iti++; sibch = *iti; } return sibch; } }
void tree_find_gprof(tree_t *tree){ char buf[10]; for(int i = 50000; i < 100000; ++i){ sprintf(buf, "%d", i); char *key = buf; tree_find(tree,key); } }
static int url_find (char *urltext) { int pos; if (tree_find (url_tree, urltext, (tree_cmp_func *)g_ascii_strcasecmp, NULL, &pos)) return 1; return 0; }
double gsl_spmatrix_get(const gsl_spmatrix *m, const size_t i, const size_t j) { if (i >= m->size1) { GSL_ERROR_VAL("first index out of range", GSL_EINVAL, 0.0); } else if (j >= m->size2) { GSL_ERROR_VAL("second index out of range", GSL_EINVAL, 0.0); } else { if (GSL_SPMATRIX_ISTRIPLET(m)) { /* traverse binary tree to search for (i,j) element */ void *ptr = tree_find(m, i, j); double x = ptr ? *(double *) ptr : 0.0; return x; } else if (GSL_SPMATRIX_ISCCS(m)) { const size_t *mi = m->i; const size_t *mp = m->p; size_t p; /* loop over column j and search for row index i */ for (p = mp[j]; p < mp[j + 1]; ++p) { if (mi[p] == i) return m->data[p]; } } else if (GSL_SPMATRIX_ISCRS(m)) { const size_t *mi = m->i; const size_t *mp = m->p; size_t p; /* loop over row i and search for column index j */ for (p = mp[i]; p < mp[i + 1]; ++p) { if (mi[p] == j) return m->data[p]; } } else { GSL_ERROR_VAL("unknown sparse matrix type", GSL_EINVAL, 0.0); } /* element not found; return 0 */ return 0.0; } } /* gsl_spmatrix_get() */
/* searches for a value in the tree and return a pointer which contains the address of the node on the tree * if no node is found return null * */ NodePtr tree_find( searchKey value, SearchTree T ) { if ( T == NULL ) //if T is empty, search fails { return NULL; } else if (value == T -> data) // found the node { return T; } else if (value < T -> data) //search left subtree { return tree_find( value, (T -> left) ); } else // search right subtree { return tree_find( value, (T -> right) ); } }
int tree_remove(tree *t, void *key, int *pos) { void *data; data = tree_find(t, key, t->cmp, t->data, pos); if (!data) return 0; tree_remove_at_pos(t, *pos); return 1; }
struct User * userlist_find (struct session *sess, const char *name) { int pos; if (sess->usertree_alpha) return tree_find (sess->usertree_alpha, name, (tree_cmp_func *)find_cmp, sess->server, &pos); return NULL; }
void find(char *args, SearchTree *tree, TreeNode **out) { int n; if (get_one_arg(args, &n)) { TreeNode *node = tree_find(tree, n); if (node) *out = node; else printf("%s\n", node_err); } }
/* find an object in the map and return it or NULL if not found */ void* map_find(map m, int key) { if (m == NULL) { return NULL; } else { tree_find(m->root, m->f, key); } }
int main (void) { TreeNode *tree_root = NULL; TreeNode *found = NULL; char *orders[4] = { "no-order", "pre-order", "in-order", "post-order" }; char buf[KEYSIZE] = ""; int record_num = 0; int ch, count = 0; prompt ("Insert"); while (*gets(buf)) { StrLcpy (rec.key, buf, KEYSIZE); rec.id = ++record_num; if (!tree_insert (&tree_root, &rec, sizeof(rec), (CmpFunc)rec_cmp)) { printf ("\n\tTree Insertion Failure!\n"); return (1); } prompt ("Insert"); } prompt ("Delete"); gets (buf); rec.key[0] = '\0'; StrLcpy (rec.key, buf, KEYSIZE); while ((found = tree_find (tree_root, &rec, (CmpFunc)rec_cmp)) != NULL) { tree_print (found->info); tree_root = tree_delete (tree_root, found); count++; } printf ("\n\t%d String(s) Deleted\n", count); printf ("\n\tSelect Tree Traversal Type\n"); printf ("\n\t\t1) pre-order\n\t\t2) in-order\n\t\t3) post-order\n\n\t>"); ch = getch(); ch -= '0'; if (ch < PRE_ORDER || ch > POST_ORDER) ch = NO_ORDER; printf ("\n\t... Walking Tree %s ...\n\n", orders[ch]); t_order = ch; tree_trace (tree_root); tree_free (tree_root); return (0); }
MNCL_RAW * mncl_acquire_raw(const char *resource) { MNCL_RAW *result = NULL; struct resmap_node seek, *found = NULL; struct provider *i = providers; char *duped_name; seek.resname = resource; found = (struct resmap_node *)tree_find(&locked_resources, (TREE_NODE *)&seek, rescmp); if (found) { ++found->refcount; return found->resource; } while (i && !result) { switch (i->tag) { case PROVIDER_DIRECTORY: result = filesystem_get_resource(i->path, resource); break; case PROVIDER_ZIPFILE: result = zipfile_get_resource(i->path, resource); break; default: /* ? */ break; } i = i->next; } if (!result) { /* Don't pollute our resource map */ return NULL; } /* Update the resource map */ found = malloc(sizeof(struct resmap_node)); duped_name = (char *)malloc(strlen(resource)+1); strcpy(duped_name, resource); found->resname = duped_name; found->resource = result; found->refcount = 1; tree_insert(&locked_resources, (TREE_NODE *)found, rescmp); /* Build another copy for the reverse map */ found = malloc(sizeof(struct resmap_node)); duped_name = (char *)malloc(strlen(resource)+1); strcpy(duped_name, resource); found->resname = duped_name; found->resource = result; found->refcount = 0; tree_insert(&reverse_map, (TREE_NODE *)found, ptrcmp); return result; }
static void* tree_find(tree t, keyfunc f, int key) { if (t == NULL) { return NULL; } int obj = f(t->object); if (obj == key) { return t->object; } else if (obj > key) { return tree_find(t->left, f, key); } else if (obj < key) { return tree_find(t->right, f, key); } }
void init_testcase_random_data(void) { unsigned int seed = time(NULL); int i; tree = tree_create(cmp_int); srandom(seed); for( i = 0 ; i < RANDOM_ARRAY_SIZE ; i++ ) { // Make sure the new element is unique. do { random_array[i] = random(); } while( tree_find(tree, &random_array[i]) ); tree_insert(tree, &random_array[i], &random_array[i]); } }
/* * Use all columns but the ones in the list. * Replaces any previously selected or excluded columns * The column names in the list should survive as long as the tableset instance. */ void tableset_exclude(TABSET tset /* tableset instance */, TREE *nocols /* list of columns to exclude */) { ITREE *colorder; char *colname; if (tset->cols) itree_destroy(tset->cols); tset->cols = itree_create(); colorder = table_getcolorder(tset->tab); itree_traverse(colorder) { colname = itree_get(colorder); if (tree_find(nocols, colname) == TREE_NOVAL) itree_append(tset->cols, colname); } }
/* * remove a pattern previously set by _setoverride(). * returns 1 if pattern was found and successfully deleted or 0 if there * was no pattern */ int elog_rmoverride(char *re_pattern /* regular expression pattern */ ) { struct elog_overridedat *over; elog_checkinit(); if ((over = tree_find(elog_override, re_pattern)) != TREE_NOVAL) { regfree(&over->pattern); nfree(over); nfree(tree_getkey(elog_override)); tree_rm(elog_override); return 1; } return 0; }
/* * Find an existing pice of music. */ musicp music_find (const char *name_alias) { music target; music *result; if (!name_alias) { ERR("no name_alias given for music find"); } memset(&target, 0, sizeof(target)); target.tree.key = (char*) name_alias; result = (typeof(result)) tree_find(all_music, &target.tree.node); if (!result) { return (0); } return (result); }
void process_radec(struct cat* cat, double ra, double dec, struct matchstack* matches) { double x=0,y=0,z=0; double cos_radius=0; //int64 nmatch=0; int64 hpixid = hpix_eq2pix(cat->hpix, ra, dec) - cat->hpix->npix/2; struct tree_node* node = tree_find(cat->tree, hpixid); matchstack_resize(matches,0); if (!cat->radius_in_file) { cos_radius = cat->cos_radius[0]; } if (node != NULL) { hpix_eq2xyz(ra,dec,&x,&y,&z); for (size_t i=0; i<node->indices->size; i++) { // index into other list size_t cat_ind = node->indices->data[i]; if (cat->radius_in_file) { cos_radius = cat->cos_radius[cat_ind]; } struct point* pt = &cat->pts[cat_ind]; double cos_angle = pt->x*x + pt->y*y + pt->z*z; if (cos_angle > cos_radius) { matchstack_push(matches, cat_ind, cos_angle); } } } return; }