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