void traverse_tree(STATIC_BSP_NODE *tree, int node, VEC3F p, VERTEX map_vertex[], int order)
{
int i;
float k;
if(tree != NULL)
{
VEC3F vert = ZERO_VEC3F;
for(i = 0; i < tree[node].poly.vnum; i++)
vert = VEC3F_SUM(vert, map_vertex[tree[node].poly.vind[i]].object);
vert = USCALE_VEC3F(vert, 1.0 / tree[node].poly.vnum);
k = VEC3F_DOT_PRODUCT(tree[node].poly.normal, VEC3F_DIFF(vert, p));
if(k * order < 0.0)
{
if(tree[node].right != -1)
traverse_tree(tree, tree[node].right, p, map_vertex, order);
if(tree[node].flag == 1)
render_poly3d(&tree[node].poly, map_vertex);
if(tree[node].left != -1)
traverse_tree(tree, tree[node].left, p, map_vertex, order);
}
else
{
if(tree[node].left != -1)
traverse_tree(tree, tree[node].left, p, map_vertex, order);
if(tree[node].flag == 1)
render_poly3d(&tree[node].poly, map_vertex);
if(tree[node].right != -1)
traverse_tree(tree, tree[node].right, p, map_vertex, order);
}
}
}
void traverse_tree(BITMAP *bitmap, NODE *node, VECTOR p, VECTOR v)
{
float k;
if(node != NULL)
{
k = VECTOR_DOT_PRODUCT(node->n, VECTOR_DIFF(node->a, p));
if(k < 0.0)
{
if(node->right != NULL)
traverse_tree(bitmap, node->right, p, v);
if(in_view(p, v, node->a, node->b))
{
vector_line(bitmap, node->a, node->b, 0);printf("%d ", node->val);
textprintf_centre_ex(bitmap, font, (node->a.x + node->b.x) * 0.5, (node->a.y+node->b.y)*0.5, makecol(0, 0, 255), -1, "%d", node->val);
}
if(node->left != NULL)
traverse_tree(bitmap, node->left, p, v);
}
else
{
if(node->left != NULL)
traverse_tree(bitmap, node->left, p, v);
if(in_view(p, v, node->a, node->b))
{
vector_line(bitmap, node->a, node->b, 0);printf("%d ", node->val);
textprintf_centre_ex(bitmap, font, (node->a.x + node->b.x) * 0.5, (node->a.y+node->b.y)*0.5, makecol(0, 0, 255), -1, "%d", node->val);
}
if(node->right != NULL)
traverse_tree(bitmap, node->right, p, v);
}
}
}
void traverse_tree(NODE *node, VEC2F p, VEC2F v, VEC2F vertex[], VERTEX map_vertex[])
{
float k;
int j = 1;
if(key[KEY_SPACE])
j = -1;
if(node != NULL)
{
VEC2F vert = vec2f(map_vertex[node->a * 2].local.x, map_vertex[node->a * 2].local.z);
k = VEC2F_DOT_PRODUCT(node->n, VEC2F_DIFF(vert, p));
if(k * j < 0.0)
{
if(node->right != NULL)
traverse_tree(node->right, p, v, vertex, map_vertex);
//if(in_view(p, v, vertex[node->a], vertex[node->b]))
draw_wall(map_vertex, node->a, node->b);
if(node->left != NULL)
traverse_tree(node->left, p, v, vertex, map_vertex);
}
else
{
if(node->left != NULL)
traverse_tree(node->left, p, v, vertex, map_vertex);
//if(in_view(p, v, vertex[node->a], vertex[node->b]))
draw_wall(map_vertex, node->a, node->b);
if(node->right != NULL)
traverse_tree(node->right, p, v, vertex, map_vertex);
}
}
}
void traverse_tree(tree *l)
{
if (l != NULL) {
traverse_tree(l->left);
process_item(l->item);
traverse_tree(l->right);
}
}
void traverse_tree(node_t *head)
{
if(head==NULL)
return;
traverse_tree(head->left);
printf("%d ", head->data);
traverse_tree(head->right);
}
void traverse_tree(BiTreePtr T){
if (T!=NULL) {
if (T->lchild==NULL && T->rchild==NULL) {
print_queue_seq(T->pdata->pickedQueue, visit_queue_elem);
}
traverse_tree(T->lchild);
traverse_tree(T->rchild);
}
}
/* Complete any outstanding commands.
*/
void
cleanup(void)
{
struct predicate *eval_tree = get_eval_tree();
if (eval_tree)
{
traverse_tree(eval_tree, complete_pending_execs);
complete_pending_execdirs(get_current_dirfd());
traverse_tree(eval_tree, flush_and_close_output_files);
}
}
void traverse_tree(tree *t)
{
if (t != NULL)
{
//process_item(t->item); // pre-order depth-first traversal
traverse_tree(t->left);
//process_item(t->item); // in-order depth-first traversal
traverse_tree(t->right);
//process_item(t->item); // post-order depth-first traversal
}
}
static void
traverse_tree(struct predicate *tree,
void (*callback)(struct predicate*))
{
if (tree->pred_left)
traverse_tree(tree->pred_left, callback);
callback(tree);
if (tree->pred_right)
traverse_tree(tree->pred_right, callback);
}
/*
* Traverse the Huffman coding tree given in the first argument,
* with the prefix so far as a string second argument.
* For leaf nodes, the prefix *is* the final code, so we store *a copy* of the prefix string in
* the structure in the original data table associated this letter. That is, the copy is stored
* in the letter's "ld_code" field.
* For interior nodes, a local string is allocated to hold the prefix with "0" appended to
* traverse the left subtree and the prefix with "1" appended to traverse the
* right subtree. By appending we end up with a code that is parsed left to right.
*/
static void traverse_tree( HTreeNode *root, char *prefix ) {
/*
* The node is a leaf it it has no descendant nodes. Since the tree is a complete
* binary tree we need only check one of the two descendant links. If this
* is a leaf, the code for the letter is the prefix - make a copy and then free
* up storage for the Huffman Tree Node (we don't need it any longer).
*/
if(root ->ht_label == ' '){
char* newString;
newString = malloc(sizeof(prefix+1));
strcpy(newString,prefix);
newString = strcat(newString,"0");
traverse_tree(root ->ht_left,newString);
free(newString);
char* newStringR;
newStringR = malloc(sizeof(prefix+1));
strcpy(newStringR,prefix);
newStringR = strcat(newStringR,"1");
traverse_tree(root ->ht_right,newStringR);
free(newStringR);
}
else{ //Hit a leaf node
int l = 0;
l = root ->ht_label-65;
data[l].ld_code = malloc(sizeof(prefix));
strcpy(data[l].ld_code,prefix);
free(root);
return;
}
/*
* Allocate space a string to hold the prefix plus one additional
* character (be careful in computing the amount of space you need!).
* Extend the prefix with a "0" and process the left tree.
* Extend the prefix with a "1" and process the right tree.
* When done, free up the space used by the local string used for
* extension *as well as* the space used by the Huffman Tree Node
* just processed - we don't need it any longer.
*/
}
void traverse_tree(typename tree_traits<Tree>::node_descriptor v,
Tree& t, TreeVisitor visitor)
{
visitor.preorder(v, t);
typename tree_traits<Tree>::children_iterator i, end;
tie(i, end) = children(v, t);
if (i != end) {
traverse_tree(*i++, t, visitor);
visitor.inorder(v, t);
while (i != end)
traverse_tree(*i++, t, visitor);
} else
visitor.inorder(v, t);
visitor.postorder(v, t);
}
void ex(node_t *p)
{
printf("digraph g%d {\n", graph_count );
traverse_tree(p);
printf("}\n");
graph_count++;
}
void traverse_tree(TreeNode *root, char *txn)
{
if (root == NULL)
return;
ItemSetNode *l;
for (l = root->item_sets; l != NULL; l = l->next)
{
if (strstr(txn, l->data->item_set) != NULL)
l->data->count = l->data->count + 1;
}
traverse_tree(root->left, txn);
traverse_tree(root->middle, txn);
traverse_tree(root->right, txn);
}
/**
* エンコード関数
* @param const char *filename 開くファイル名
* @return int 成功
*/
int encode(const char *filename)
{
count_symbols(filename); // シンボル数のカウント
Node *root = build_tree(); // 符号の木を作る
traverse_tree(0, root); // 符号を当てる
return 1;
}
/*
* Traverses the Huffman tree and assigns 0 or 1 to
* children to create the bit code for a char
*/
void traverse_tree(struct tree_node * tree, char * bit_code)
{
char temp[255] = ""; //worst case height for huffman tree
if(tree->left != NULL) {
strcpy(temp, bit_code);
strcat(temp, "0");
traverse_tree(tree->left, temp);
}
if(tree->right != NULL) {
strcpy(temp, bit_code);
strcat(temp,"1");
traverse_tree(tree->right, temp);
}
printf("%s\n", temp);
bit_code = temp; // store bit code in bit_code var
}
/**
* 木をなぞって符号を当てる関数
* @param const int depth 探索の深さ
* @param const Node *np 現在のノード
*/
void traverse_tree(const int depth, const Node *np)
{
static char code[NSYMBOLS] = {0}; // 符号
assert(depth < NSYMBOLS);
if (np->left == NULL) // 葉にしか要素はない
{
// 符号語を表示
code[depth] = '\0';
printf("0x%02x -> %s\n", (unsigned int)np->symbol, code);
return;
}
code[depth] = '0'; // 0を詰める
traverse_tree(depth + 1, np->left);
code[depth] = '1'; // 1を詰める
traverse_tree(depth + 1, np->right);
}
void
traverse_tree(struct movement_bintree* tree)
{
#ifdef DEBUG
puts("call traverse_tree");
#endif
if(tree == NULL) {
return;
}
traverse_tree(tree->right);
printf("%lu%s\n",
tree->node.disk,
movements_string[tree->node.poles]
);
traverse_tree(tree->left);
}
/*
* Main driver program.
* The arguments are ignored.
*/
int main ( int ac, char **av ) {
read_file() ;
initialize_ordered_list() ;
build_huffman_tree();
traverse_tree( ol_remove(), "" ) ;
print_codes() ;
exit(0) ;
}
/* lookup by cbk_handle. Common part of coord_by_key() and
reiser4_object_lookup(). */
static lookup_result coord_by_handle(cbk_handle * handle)
{
/*
* first check cbk_cache (which is look-aside cache for our tree) and
* of this fails, start traversal.
*/
/* first check whether "key" is in cache of recent lookups. */
if (cbk_cache_search(handle) == 0)
return handle->result;
else
return traverse_tree(handle);
}
int main_test(void){
BiTree *T = NULL;
init_tree(&T);
process_input(T);
build_tree(T);
traverse_tree(T);
return 0;
}
int main(int argc, char *argv[]) {
tree *root = NULL;
insert_tree(&root, 33/*, root*/);
insert_tree(&root, 622/*, root*/);
insert_tree(&root, 22/*, root*/);
insert_tree(&root, 17/*, root*/);
insert_tree(&root, 441/*, root*/);
insert_tree(&root, 91/*, root*/);
printf("Find minimum = %d\n", (find_minimum(root))->item );
printf("Inorder Traversal of Tree:\n");
traverse_tree(root);
}
void traverse_tree(BITMAP *bitmap, NODE *node, VEC2F p, VEC2F v, VEC2F vertex[])
{
float k;
if(node != NULL)
{
k = VEC2F_DOT_PRODUCT(node->n, VEC2F_DIFF(vertex[node->a], p));
if(k < 0.0)
{
if(node->right != NULL)
traverse_tree(bitmap, node->right, p, v, vertex);
if(in_view(p, v, vertex[node->a], vertex[node->b]))
{
vec2f_line(bitmap, vertex[node->a], vertex[node->b], 0); printf("%d ", node->val);
textprintf_centre_ex(bitmap, font, (vertex[node->a].x + vertex[node->b].x) * 0.5 + SCREEN_W * 0.5,
(vertex[node->a].y + vertex[node->b].y) * 0.5 + SCREEN_H * 0.5,
makecol(0, 0, 255), -1, "%d", node->val);
}
if(node->left != NULL)
traverse_tree(bitmap, node->left, p, v, vertex);
}
else
{
if(node->left != NULL)
traverse_tree(bitmap, node->left, p, v, vertex);
if(in_view(p, v, vertex[node->a], vertex[node->b]))
{
vec2f_line(bitmap, vertex[node->a], vertex[node->b], 0); printf("%d ", node->val);
textprintf_centre_ex(bitmap, font, (vertex[node->a].x + vertex[node->b].x) * 0.5 + SCREEN_W * 0.5,
(vertex[node->a].y + vertex[node->b].y) * 0.5 + SCREEN_H * 0.5,
makecol(0, 0, 255), -1, "%d", node->val);
}
if(node->right != NULL)
traverse_tree(bitmap, node->right, p, v, vertex);
}
}
}
static void mesh_generate(){
// double ppwl = param->factor / param->freq;
// double myfactor = param->factor;
Octree tree = octor_newtree();
tree.root = refine_tree(&tree.root, &toexpand, &query_model);
vector<Element> elements;
unordered_map<int , Node> nodes;
elements = traverse_tree(&tree.root, elements);
print_vector(elements, "/Users/kelicheng/Desktop/mymesh.txt");
nodes = extract_mesh(elements);
print_nodes(nodes, "/Users/kelicheng/Desktop/mynodes.txt");
}
/**
* 木をなぞって符号を当てる関数
* @param const int depth 探索の深さ
* @param const Node *np 現在のノード
*/
void traverse_tree(const int depth, const Node *np, FILE *fp)
{
static char code[NSYMBOLS] = {0}; // 符号
assert(depth < NSYMBOLS);
if (np->left == NULL) // 葉にしか要素はない
{
// 符号語を表示
code[depth] = '\0';
strcpy((char *)(np->code), code); // コードを保存
// if (np->symbol != NSYMBOLS - 1) // EOFは登録しない
fprintf(fp, "%d %s\n", np->symbol, code);
#ifdef DEBUG
printf("0x%02x -> %s\n", np->symbol, code);
#endif
return;
}
code[depth] = '0'; // 0を詰める
traverse_tree(depth + 1, np->left, fp);
code[depth] = '1'; // 1を詰める
traverse_tree(depth + 1, np->right, fp);
}
int
main(int argc, char **argv)
{
struct movement_bintree *root = NULL;
if(argc > 1) {
long i = atol(argv[1]);
if(i < 0) {
exit(EXIT_FAILURE);
}
root = compute_tree(root, (unsigned long)i);
traverse_tree(root);
exit(EXIT_SUCCESS);
}
exit(EXIT_FAILURE);
}
static void
traverse_tree(TreeNode *x)
{
int nc, i;
struct nonterm *nt;
TreeNode *c;
if (x->type == N_NONTERM) {
nt = &x->data.nonterm;
/* Process specific types of node */
switch (nt->type) {
case GIHEK:
process_gihek(x);
break;
case EK:
process_ek(x);
break;
case JEK:
case JEK_OPT_KE:
case JEK_OPT_KEBO:
process_jek(x);
break;
case GUHEK:
process_guhek(x);
break;
case GEK:
process_gek(x);
break;
default:
break;
}
nc = nt->nchildren;
for (i=0; i<nc; i++) {
c = nt->children[i];
traverse_tree(c);
}
}
}
int main(int argc ,char *argv[])
{
/* Please keep all the files that you are using have this as the basic code */
circle *tree; // create the doc object
tree=create_circle(NULL); // initialize the datastructure
read_ssf_from_file(tree,argv[1]); // read from the file into tree
int sentence=sentences(tree);
node * temp[sentence]; // create the node object to store all the nodes retuned
int count=0,i,k; // count to count the # of sentences or nodes returned
count=traverse_tree(tree,temp,count); // function which returns all the sentence nodes into temp
for(i=0;i<count;i++) {
child(temp[i]);
}
print_tree_to_file(tree, "temp.txt");
return 0;
}
ItemSetNode *get_frequent_itemsets(TreeNode *root)
{
FILE *fp = fopen(DATA_FILE, "r");
char *line = NULL;
while ((line = read_line(fp)) != NULL && *line != '\0')
{
traverse_tree(root, line);
free(line);
}
fclose(fp);
ItemSetNode *tmp = NULL;
get_leaves(root, &tmp);
return tmp;
}
void traverse_tree(node_t *p)
{
int i =0;
if (p->type == typeOpr ) {
printf("node%p [label=%d]\n", p, p->opr.oper);
for (i=0; i<p->opr.nops; i++)
printf("node%p -> node%p\n", p, p->opr.op[i]);
for (i=0; i < p->opr.nops; i++)
traverse_tree(p->opr.op[i]);
}
switch(p->type) {
case typeIntConst :
printf("node%p [label=int]\n", p); break;
case typeChrConst :
printf("node%p [label=char]\n", p); break;
case typeStrConst:
printf("node%p [label=str]\n", p); break;
case typeArray :
printf("node%p [label=arr]\n", p); break;
}
}
/**
* エンコード関数
* @param const char *filename 開くファイル名
* @return int 成功
*/
int encode(const char *filename)
{
FILE *fp;
char *mapfile;
count_symbols(filename); // シンボル数のカウント
Node *root = build_tree(); // 符号の木を作る
mapfile = change_extention(filename, ".maps");
if ((fp = fopen(mapfile, "w")) == NULL)
{
fprintf(stderr, "Cannot Open Mapping File\n");
exit(1);
}
free(mapfile);
fprintf(fp, "%s\n", filename); // ファイル名を入れておく
traverse_tree(0, root, fp); // 符号を当てる
fclose(fp);
compress(root, filename); // 圧縮
printf("finished\n");
return 1;
}
