int tree_size(tree *root) { if (root == NULL) return (0); else return (1 + tree_size(root->left) + tree_size(root->right)); }
static int tree_size(node_t *node) { if (!node) return 0; return (tree_size(node->left) + tree_size(node->right) + 1); }
static void write_obj(FILE *file, WObj *obj, int lvl) { WWsSplit *split; int tls, brs; if(WOBJ_IS(obj, WFrame)){ indent(file, lvl); fprintf(file, "frame %d\n", ((WFrame*)obj)->frame_id); return; } if(!WOBJ_IS(obj, WWsSplit)) return; split=(WWsSplit*)obj; tls=tree_size(split->tl, split->dir); brs=tree_size(split->br, split->dir); indent(file, lvl); if(split->dir==HORIZONTAL) fprintf(file, "hsplit %d, %d {\n", tls, brs); else fprintf(file, "vsplit %d, %d {\n", tls, brs); write_obj(file, split->tl, lvl+1); write_obj(file, split->br, lvl+1); indent(file, lvl); fprintf(file, "}\n"); }
int tree_size(Node* ptr) { if (ptr == 0) { return 0; } else { return 1 + tree_size(ptr->left_ptr()) + tree_size(ptr->right_ptr()); } }// tree_size
/** * Returns the size of the tree. */ int tree_size(TreeNode* tree) { if (tree == NULL) { return 0; } else { return tree_size(tree->left) + tree_size(tree->right) + 1; } }
int tree_size(treenode_t *tree) { int i = 1; if (tree == NULL) return 0; else { i += tree_size(tree->left); i += tree_size(tree->right); return i; } }
int tree_size(struct node* node) { if (node==NULL) { return(0); } else { return(tree_size(node->left) + tree_size(node->right) + 1); } }
int tree_size(TREE_NODE *root){ static int count = 0; if(root) { count++; tree_size(root->left); tree_size(root->right); } else return count; return count; }
unsigned int tree_size( SearchTree T ) { // returns 0 if T is NULL if (T == NULL) { return 0; } else { return ( tree_size(T -> left) + tree_size(T -> right) + 1); } }
void dump_simtrace( anode_t *head, ptree_t *evar_list, ptree_t *svar_list, FILE *fp ) { int j, last_nonzero_env, last_nonzero_sys; anode_t *node; int node_counter = 0; ptree_t *var; int num_env, num_sys; if (fp == NULL) fp = stdout; num_env = tree_size( evar_list ); num_sys = tree_size( svar_list ); node = head; while (node->mode != 0) /* Find starting state */ node = node->next; while (node->trans_len >= 0) { fprintf( fp, "%d: ", node_counter ); last_nonzero_env = num_env-1; last_nonzero_sys = num_sys-1; if (last_nonzero_env < 0 && last_nonzero_sys < 0) { fprintf( fp, "{}" ); } else { for (j = 0; j < num_env; j++) { var = get_list_item( evar_list, j ); if (j == last_nonzero_env) { fprintf( fp, "%s=%d", var->name, *(node->state+j) ); fprintf( fp, ", " ); } else { fprintf( fp, "%s=%d, ", var->name, *(node->state+j) ); } } for (j = 0; j < num_sys; j++) { var = get_list_item( svar_list, j ); if (j == last_nonzero_sys) { fprintf( fp, "%s=%d", var->name, *(node->state+num_env+j) ); } else { fprintf( fp, "%s=%d, ", var->name, *(node->state+num_env+j) ); } } } fprintf( fp, "\n" ); if (node->trans_len == 0) break; node_counter++; node = *(node->trans); } }
void logprint_state( vartype *state ) { int i; int num_env, num_sys; num_env = tree_size( spc.evar_list ); num_sys = tree_size( spc.svar_list ); for (i = 0; i < num_env+num_sys; i++) { logprint( "\t%s = %d;", (i < num_env ? (get_list_item( spc.evar_list, i ))->name : (get_list_item( spc.svar_list, i-num_env ))->name), *(state+i) ); } }
END_TEST START_TEST(test_table_encode) { TreeNode *t = huffman_build_tree("books/holmes.txt");//holmes ck_assert_int_eq(tree_size(t), 161); EncodeTable *etab = table_build(t); ck_assert_msg(etab != NULL, "Encode table should not be NULL."); char* e_encode = table_bit_encode(etab, 'e'); ck_assert_msg(e_encode != NULL, "Problem finding the encoding for 'e'."); ck_assert_int_eq(e_encode[0], 0); ck_assert_int_eq(e_encode[1], 0); ck_assert_int_eq(e_encode[2], 0); ck_assert_int_eq(e_encode[3], 0); ck_assert_int_eq(e_encode[4], -1); free(e_encode); char* space_encode = table_bit_encode(etab, ' '); ck_assert_msg(space_encode != NULL, "Problem finding the encoding for ' '."); ck_assert_int_eq(space_encode[0], 1); ck_assert_int_eq(space_encode[1], 0); ck_assert_int_eq(space_encode[2], -1); free(space_encode); free(t); free(etab); }
static ssize_t addrs_count(backend_t *chain, request_t *request){ size_t units; data_t *buffer; data_ctx_t *buffer_ctx; file_userdata *data = ((file_userdata *)chain->userdata); if( (buffer = hash_get_data(request, HK(buffer))) == NULL) return -EINVAL; buffer_ctx = hash_get_data_ctx(request, HK(buffer)); if(hash_find(request, HK(blocks)) == NULL){ if(tree_size(data->tree, &units) != 0) return -EINVAL; }else{ units = tree_blocks_count(data->tree); } data_t dt_units = DATA_PTR_OFFT(&units); return data_transfer( buffer, buffer_ctx, &dt_units, NULL ); }
int main(int argc, char* argv[]) { node_t *root = NULL; root = tree_insert(NULL, 20); root = tree_insert(root, 10); root = tree_insert(root, 100); root = tree_insert(root, 30); //printf("%d\n", !tree_lookup(root, 1)); //printf("%d\n", !tree_lookup(root, 2)); //printf("%d\n", !tree_lookup(root, 3)); //printf("%d\n", !tree_lookup(root, 4)); printf("%d\n", tree_min_val(root)); printf("%d\n", tree_max_val(root)); printf("%d\n", tree_size(root)); printTree(root); #if 0 printf("1 %d\n", !check("a(b)")); printf("1 %d\n", !check("[{}]")); printf("0 %d\n", !check("[")); printf("0 %d\n", !check("}{")); printf("1 %d\n", !check("z([{}-()]{a})")); #endif return 1; }
void main() { int a[30]; int count = 0; struct tree_node *root = NULL; root = tree_add_node(1); root->left = tree_add_node(2); root->right = tree_add_node(3); root->left->left = tree_add_node(4); root->left->left->right = tree_add_node(10); root->left->right = tree_add_node(5); root->left->right->right = tree_add_node(50); root->right->left = tree_add_node(6); root->right->right = tree_add_node(7); struct tree_node *root2 = NULL; root2 = tree_add_node(1); root2->left = tree_add_node(2); root2->right = tree_add_node(3); root2->left->left = tree_add_node(4); root2->left->left->right = tree_add_node(10); root2->left->right = tree_add_node(5); root2->right->left = tree_add_node(6); root2->right->right = tree_add_node(7); //tree_preorder_print(root); tree_postorder_iterative_print(root); printf("Tree size(9) = %d\n", tree_size(root)); printf("Height is %d\n", tree_height(root)); printf("Check identical for same tree = %d\n", tree_check_identical(root, root2)); tree_mirror(root); tree_postorder_iterative_print(root); tree_r2l_path(root, a, count); }
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; }
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); }
/* * Number of nodes in the tree */ int tree_size(Tree_node root) { if ( !root ) return 0; int siz = 1; ITERA(Tree_node, node, root->child, sibling) siz += tree_size(node); return siz; }
END_TEST START_TEST(test_tree_size) { TreeNode *t = tree_new(); t->left = tree_new(); t->right = tree_new(); ck_assert_int_eq(tree_size(t), 3); tree_free(t); }
END_TEST START_TEST(test_tree_properties) { tree_info_t info; ck_assert_ptr_eq(tree_info(tree, &info), &info); ck_assert_int_eq(info.size, tree_size(tree)); ck_assert_int_le(info.height, info.min_height*2); }
// This method shuould be locked // It makes an array pointing to all the values in the map. // You can modify the values of this map. list map_values(map m) { pthread_mutex_lock(m->mutex); int i = 0; list datas = tree_to_list(m->t); list l = list_init(); for (i=0; i < tree_size(m->t); i++) { list_add(l, ((data*)list_get(datas, i))->value); } list_free(datas); pthread_mutex_unlock(m->mutex); return l; }
int kth_largest(tree *root, int k) { if (root == NULL || k < 0) return (-1); int size = tree_size(root); if (k > size) return (-1); int nk = size - k; return (kth_smallest(root, &nk)); }
END_TEST START_TEST(test_table_free) { TreeNode *t = huffman_build_tree("books/holmes.txt");//holmes ck_assert_int_eq(tree_size(t), 161); EncodeTable *etab = table_build(t); ck_assert_msg(etab != NULL, "Encode table should not be NULL."); free(t); free(etab); }
END_TEST ////////////////////////////////////////////////////////////////////// ///////////// huffman unit tests ////////////////////////////////////////////////////////////////////// START_TEST(test_huffman_build_tree) { TreeNode *t; t = huffman_build_tree("books/aladdin.txt"); ck_assert_msg(t != NULL, "Tree should not be NULL."); ck_assert_int_eq(tree_size(t), 115); free(t); t = huffman_build_tree("books/holmes.txt"); ck_assert_msg(t != NULL, "Tree should not be NULL."); ck_assert_int_eq(tree_size(t), 161); free(t); t = huffman_build_tree("books/iliad.txt"); ck_assert_msg(t != NULL, "Tree should not be NULL."); ck_assert_int_eq(tree_size(t), 131); free(t); t = huffman_build_tree("books/KJV.txt"); ck_assert_msg(t != NULL, "Tree should not be NULL."); ck_assert_int_eq(tree_size(t), 147); free(t); t = huffman_build_tree("books/newton.txt"); ck_assert_msg(t != NULL, "Tree should not be NULL."); ck_assert_int_eq(tree_size(t), 187); free(t); t = huffman_build_tree("books/odyssy.txt"); ck_assert_msg(t != NULL, "Tree should not be NULL."); ck_assert_int_eq(tree_size(t), 161); free(t); t = huffman_build_tree("books/poems.txt"); ck_assert_msg(t != NULL, "Tree should not be NULL."); ck_assert_int_eq(tree_size(t), 185); free(t); t = huffman_build_tree("books/shakespeare.txt"); ck_assert_msg(t != NULL, "Tree should not be NULL."); ck_assert_int_eq(tree_size(t), 159); free(t); }
/* * Given a tree and position, returns subtree's node. * * Returns NULL if child tree not found. */ struct node *get_node(struct tree *t, size_t i) { log_assert(t); if (tree_size(t) > 1) t = tree_index(t, i); if (t == NULL) return NULL; struct node *n = t->data; log_assert(n); return n; }
static void url_add (char *urltext, int len) { char *data; int size; if (!prefs.url_grabber) return; data = malloc (len + 1); if (!data) return; memcpy (data, urltext, len); data[len] = 0; if (data[len - 1] == '.') /* chop trailing dot */ { len--; data[len] = 0; } if (data[len - 1] == ')') /* chop trailing ) */ data[len - 1] = 0; if (url_find (data)) { free (data); return; } if (!url_tree) url_tree = tree_new ((tree_cmp_func *)g_ascii_strcasecmp, NULL); size = tree_size (url_tree); /* 0 is unlimited */ if (prefs.url_grabber_limit > 0 && size >= prefs.url_grabber_limit) { /* the loop is necessary to handle having the limit lowered while xchat is running */ size -= prefs.url_grabber_limit; for(; size > 0; size--) tree_remove_at_pos (url_tree, 0); } tree_append (url_tree, data); fe_url_add (data); }
static void loop() { alarm(10); while (likely(!signal_quit)) { #if 0 { /* sanity check */ void tc(thread_t * thread) { assert(thread->references == 2); } void pc(process_t * process) { assert(!tree_empty(&process->threads)); assert(process->references == 2 + tree_size(&process->threads)); thread_iter(process, tc); } process_iter(pc); }
// check static bool check_sizes(rba_buffer_t *b) { uint32_t s; s = tree_size(b); if (s != b->nterms) { printf("invalid tree: size = %"PRIu32", nterms = %"PRIu32"\n", s, b->nterms); fflush(stdout); return false; } s = free_list_size(b); if (s != b->num_nodes - b->nterms - 1) { printf("invalid free list: size = %"PRIu32", should be %"PRIu32"\n", s, b->num_nodes - b->nterms - 1); fflush(stdout); return false; } return true; }
END_TEST START_TEST(test_huffman_find) { TreeNode *t = huffman_build_tree("books/holmes.txt");//holmes ck_assert_int_eq(tree_size(t), 161); EncodeTable *etab = table_build(t); ck_assert_msg(etab != NULL, "Encode table should not be NULL."); char* e_encode = table_bit_encode(etab, 'e'); ck_assert_msg(e_encode != NULL, "Problem finding the encoding for 'e'."); char c = huffman_find(t, e_encode); ck_assert_int_eq(c, 'e'); char* b_encode = table_bit_encode(etab, 'b'); c = huffman_find(t, b_encode); ck_assert_int_eq(c, 'b'); }
void release_ssa_name (tree var) { if (!var) return; /* Never release the default definition for a symbol. It's a special SSA name that should always exist once it's created. */ if (SSA_NAME_IS_DEFAULT_DEF (var)) return; /* If VAR has been registered for SSA updating, don't remove it. After update_ssa has run, the name will be released. */ if (name_registered_for_update_p (var)) { release_ssa_name_after_update_ssa (var); return; } /* release_ssa_name can be called multiple times on a single SSA_NAME. However, it should only end up on our free list one time. We keep a status bit in the SSA_NAME node itself to indicate it has been put on the free list. Note that once on the freelist you can not reference the SSA_NAME's defining statement. */ if (! SSA_NAME_IN_FREE_LIST (var)) { tree saved_ssa_name_var = SSA_NAME_VAR (var); int saved_ssa_name_version = SSA_NAME_VERSION (var); use_operand_p imm = &(SSA_NAME_IMM_USE_NODE (var)); if (MAY_HAVE_DEBUG_STMTS) insert_debug_temp_for_var_def (NULL, var); #ifdef ENABLE_CHECKING verify_imm_links (stderr, var); #endif while (imm->next != imm) delink_imm_use (imm->next); (*SSANAMES (cfun))[SSA_NAME_VERSION (var)] = NULL_TREE; memset (var, 0, tree_size (var)); imm->prev = imm; imm->next = imm; imm->loc.ssa_name = var; /* First put back the right tree node so that the tree checking macros do not complain. */ TREE_SET_CODE (var, SSA_NAME); /* Restore the version number. */ SSA_NAME_VERSION (var) = saved_ssa_name_version; /* Hopefully this can go away once we have the new incremental SSA updating code installed. */ SET_SSA_NAME_VAR_OR_IDENTIFIER (var, saved_ssa_name_var); /* Note this SSA_NAME is now in the first list. */ SSA_NAME_IN_FREE_LIST (var) = 1; /* And finally put it on the free list. */ vec_safe_push (FREE_SSANAMES (cfun), var); } }