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