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;
}
