/* procedure printTree prints a syntax tree to the * listing file using indentation to indicate subtrees */ void printTree( TreeNode * tree ) { int i; INDENT; while (tree != NULL) { printSpaces(); if (tree->nodekind==StmtK){ switch (tree->kind.stmt) { case IfK: fprintf(listing,"If\n"); break; case RepeatK: fprintf(listing,"Repeat\n"); break; case ForK: fprintf(listing,"For\n"); break; case AssignK: fprintf(listing,"Assign to: %s\n",tree->attr.name); break; case ReadK: fprintf(listing,"Read: %s\n",tree->attr.name); break; case WriteK: fprintf(listing,"Write\n"); break; default: fprintf(listing,"Unknown ExpNode kind\n"); break; } } else if (tree->nodekind==ExpK){ switch (tree->kind.exp) { case OpK: fprintf(listing,"Op: "); printToken(tree->attr.op,"\0"); break; case ConstK: fprintf(listing,"Const: %d\n",tree->attr.val); break; case IdK: fprintf(listing,"Id: %s\n",tree->attr.name); break; default: fprintf(listing,"Unknown ExpNode kind\n"); break; } } else fprintf(listing,"Unknown node kind\n"); for (i=0;i<MAXCHILDREN;i++) printTree(tree->child[i]); tree = tree->sibling; } UNINDENT; }
int search(Board b, int maxDepth, int m, int n) { searchNode* head = new searchNode(b); nodeCounter = 0; std::cout << "\n** R.Reti Endgame Board **\n"; head->printBoardImage(); int topHeurisic = _search(head,maxDepth,0,UNSET); printTree(head,m,n); printBest(head); return topHeurisic; }
void Test(char* testName, BinaryTreeNode* pRootOfTree) { if(testName != NULL) printf("%s begins:\n", testName); printTree(pRootOfTree); BinaryTreeNode* pHeadOfList = convertBSTToList(pRootOfTree); PrintDoubleLinkedList(pHeadOfList); }
// Prints the tree to the screen in a readable fashion. It should look just like // Racket code; use parentheses to indicate subtrees. void printTree(Value *tree) { Value *list_pointer = tree; // handle printing dependent on what type the item in the list is. while ((*list_pointer).type == CONS_TYPE) { Value *car_of_list_pointer = car(list_pointer); //printf("%u", (*car_of_list_pointer).type); switch ((*car_of_list_pointer).type) { case STR_TYPE: printf("%s", (*car_of_list_pointer).s); break; case DOUBLE_TYPE: printf("%f", (*car_of_list_pointer).d); break; case INT_TYPE: printf("%i", (*car_of_list_pointer).i); break; case CONS_TYPE: printf("("); printTree(car_of_list_pointer); printf(")"); break; case NULL_TYPE: printf("()"); break; case OPEN_TYPE: // do nothing. break; case CLOSE_TYPE: // do nothing. break; case BOOL_TYPE: if ((*car_of_list_pointer).i == 1) { printf("#t"); } else { printf("#f"); } break; case SYMBOL_TYPE: printf("%s", (*car_of_list_pointer).s); break; case PTR_TYPE: break; } if ((*((*list_pointer).c).cdr).type != NULL_TYPE) { printf(" "); } list_pointer = ((*list_pointer).c).cdr; } }
int main(int argc, char *argv[]) { struct Tree *gameTree = malloc (sizeof(struct Tree)); gameTree->root = parseFile(); if (DEBUG) printTree(gameTree); play (gameTree); writeFile(gameTree); clearTree(gameTree); return 0; }
int main( int argc, char * argv[] ) { TreeNode * syntaxTree; char pgm[120]; /* source code file name */ if (argc != 2) { fprintf(stderr,"usage: %s <filename>\n",argv[0]); exit(1); } strcpy(pgm,argv[1]) ; if (strchr (pgm, '.') == NULL) strcat(pgm,".cm"); source = fopen(pgm,"r"); if (source==NULL) { fprintf(stderr,"File %s not found\n",pgm); exit(1); } listing = stdout; /* send listing to screen */ fprintf(listing,"\nTINY COMPILATION: %s\n",pgm); #if NO_PARSE while (getToken()!=ENDFILE); #else syntaxTree = parse(); if (TraceParse) { fprintf(listing,"\nSyntax tree:\n"); printTree(syntaxTree); } #if !NO_ANALYZE if (! Error) { if (TraceAnalyze) fprintf(listing,"\nBuilding Symbol Table...\n"); buildSymtab(syntaxTree); if (TraceAnalyze) fprintf(listing,"\nChecking Types...\n"); typeCheck(syntaxTree); if (TraceAnalyze) fprintf(listing,"\nType Checking Finished\n"); } #if !NO_CODE if (! Error) { char * codefile; int fnlen = strcspn(pgm,"."); codefile = (char *) calloc(fnlen+4, sizeof(char)); strncpy(codefile,pgm,fnlen); strcat(codefile,".tm"); code = fopen(codefile,"w"); if (code == NULL) { printf("Unable to open %s\n",codefile); exit(1); } codeGen(syntaxTree,codefile); fclose(code); } #endif #endif #endif fclose(source); return 0; }
void printTree(huffmanTree* completed) { if(isLeaf(completed)) { printdepthOfNode(completed); return; } if(completed->left!=NULL) { printTree(completed->left); } if(completed->right!=NULL) { printTree(completed->right); } return; }
int main(int argc, const char * argv[]) { node<int> *root = new node<int>; root->data = 0; node<int> *child1 = new node<int>; child1->data = 1; node<int> *child5 = new node<int>; child5->data = 5; node<int> *child3 = new node<int>; child3->data = 3; node<int> *child4 = new node<int>; child4->data = 4; node<int> *child2 = new node<int>; child2->data = 2; node<int> *child12 = new node<int>; child12->data = 12; node<int> *child6 = new node<int>; child6->data = 6; node<int> *child9 = new node<int>; child9->data = 9; node<int> *child8 = new node<int>; child8->data = 8; node<int> *child7 = new node<int>; child7->data = 7; child6->left = child4; child4->parent = child6; child6->right = child9; child9->parent = child6; child4->left = child3; child3->parent = child4; child4->right = child5; child5->parent = child4; child3->left = child1; child1->parent = child3; child9->left = child7; child7->parent = child9; printTree(child6); node<int> *ancestor = findCommonAncestor(child1, child9); if ( ancestor ) std::cout << "\nfound common ancestor = " << ancestor->data << "\n"; else std::cout << "\nno common ancestor found\n"; ancestor = findCommonAncestor(child9, child1); if ( ancestor ) std::cout << "\nsearching the other way = " << ancestor->data << "\n"; else std::cout << "\nno common ancestor found\n"; return 0; }
void printTreeList(ListObject * trees, int indent) { if (trees == 0) { return; } printTree(trees->value, indent); while (trees->next != 0) { trees = trees->next; printTree(trees->value, indent); } }
void printTree(FILE *fp, treeNode *root) { if(root == NULL) { return; } //printf("\n\n%-30s", root->token); fprintf(fp, "<list>\n"); fprintf(fp, "%s\n", root->token); mergeSort( &(root->pathRecords) ); printRecords(fp, root->pathRecords); fprintf(fp, "</list>\n"); printTree(fp, root->left); printTree(fp, root->right); }
void XMLParser::printTree(xmlNodePtr start, int depth) const { for(int i=0;i<depth;i++) printf("%d",(i+1)%10); printf("\"%s\":\"%s\"\n",(start->name),this->getNodeContent(start).c_str()); xmlNodePtr i = this->getChild(start); for(;i;i= this->getNext(i)) { printTree(i,depth+1); } }
void bipartGraphPrint(bpGraph_t *pGraph) { printf("Vertices:\n"); printf("Part 1:\n"); printTree(pGraph->vpVertsP1); printf("\n"); printf("Part 2:\n"); printTree(pGraph->vpVertsP2); printf("\n"); printf("Edges:\n"); /* partite 1 to partite 2 edges. */ printf("Part 1 to 2:\n"); printLList(pGraph->vpVertsP1); /* partite 2 to partite 1 edges. */ printf("Part 2 to 1:\n"); printLList(pGraph->vpVertsP2); } /* end of bipartGraphPrint() */
int main(void) { BST<int> myTree; myTree.insert(3); for (int32_t k = 20; k < 100; k += 1) { myTree.insert(k); } printTree(myTree); }
void printTree (tree t) { if (t == NULL) return; for (; t != NULL; t = t->next) { printf ("%*s%s", indent, "", tokName[t->kind]); switch (t->kind) { case Ident: printf (" %s (%d)\n", id_name(t->value), t->value); break; case IntConst: printf (" %d\n", t->value); break; default: printf ("\n"); indent += 2; printTree (t->first); printTree (t->second); printTree (t->third); indent -= 2; } // end switch } // end for loop } // end printTree()
void imprime_hash(Thash *hash) { int i; unsigned int cont=0; for(i = 0; i < TAM_HASH; i++) { printTree(hash[i].raiz,&cont); } printf("n_uniq %u\n",cont); printf("sum_uniq %llu\n",numdist); }
//Prints the bit representation of the given leaf void printTree(TREE *fir) { //postorder print of the path to the given leaf if(getParent(fir)!=NULL) { printTree(getParent(fir)); if(getLeft(getParent(fir))==fir) printf("0"); else printf("1"); } }
int main() { char *values; int size; readExpression(&values, &size); initStack(size); createTree(values, size); printTree("tree.txt"); return EXIT_SUCCESS; }
/*============================================== Prints the Tree ==============================================*/ void printTree(TreeBranch * cur, int indent) { int i = 0; while(i < indent) { printf(" "); i++; } if(cur->type != NULL) printf("%s ", cur->type); if(cur->subtype != NULL) printf("%s ", cur->subtype); if(cur->attribute != NULL) printf("[%s]\n", cur->attribute); else if(cur->flag == 1) printf("%i\n", cur->num); else printf("\n"); if(cur->child1 != NULL) { printf("child1: "); printTree(cur->child1, (indent+2)); } if(cur->child2 != NULL) { printf("child2: "); printTree(cur->child2, (indent+2)); } if(cur->child3 != NULL) { printf("child3: "); printTree(cur->child3, (indent+2)); } if(cur->sibling != NULL) { printf("sibling: "); printTree(cur->sibling, indent); } return; }
void BinarySearchTree<T>::printTree(Node<T>* subTree, Order order) const { if (subTree == nullptr) return; switch (order) { case Order::PRE_ORDER: std::cout<<subTree->getValue()<<" "; printTree(subTree->getLeft(), order); printTree(subTree->getRight(),order); break; case 1: printTree(subTree->getLeft(), order); std::cout<<subTree->getValue()<<" "; printTree(subTree->getRight(),order); break; case 2: printTree(subTree->getLeft(), order); printTree(subTree->getRight(),order); std::cout<<subTree->getValue()<<" "; break; } }
int main(int argc, char **argv) { //Checking error if (argc < 2) { printf("usage: %s <input_filename>\n", argv[0]); return 0; } //Open file FILE *in = fopen(argv[1], "r"); if (in == NULL) return 0; //Declaration of variable int i, size,level; //Scanning size from file fscanf(in, "%d", &size); //allocating memory for array int *array = malloc(size * sizeof(int)); //Scanning number from the file for (i=0; i<size; i++) fscanf(in, "%d", &array[i]); //Declaring a node bst *root =NULL; //Creating BST root=createBST(array,size); //print in-order,pre-order,post-order tree traversal printf("Creating Binary Search Tree...\n"); printf("In-order traversal: "); printInorder(root); printf("\n"); printf("Pre-order traversal: "); printPreorder(root); printf("\n"); printf("Post-order traversal: "); printPostorder(root); printf("\n"); //Sort arrat sort(array,size); //Creatin binary tree with minimum level root=createMinBST(array,0,size-1); //printing BST printf("Minimum Height BST\n"); printTree(root); //Bonus printf("Bonus.Please enter level of the tree:"); scanf("%d",&level); if(level>height(root)) printf("\nThe maximum height of this tree is %d",height(root)); else printGivenLevel(root,level); return 0; }
int testmain() { Object *root = CreateObject("Undefined", "Undefined", 0, CodeBlock, "int"); Object *basetype = CreateObject("BaseType", "BaseType", 0, Type, 0); Object *rect = CreateObject("Rectangle", "BaseType_Rectangle", basetype, Type, 0); Object *rectConst = CreateObject("Rectangle", "Rectangle_Rectangle_Rectangle_int_int", 0, Constructor, "Rectangle"); Object *subexpr = CreateObject(0, 0, 0, Expression, "float"); addCode(subexpr, "3.14159"); addParam(rectConst, "int"); addParam(rectConst, "int"); addSymbol(rectConst, CreateObject("width", "width", 0, Variable, "int")); addSymbol(rectConst, CreateObject("height", "height", 0, Variable, "int")); addSymbol(rectConst, CreateObject("self", "self", 0, Variable, "Rectangle*")); addCode(rectConst, "Rectangle * Rectangle_Rectangle_Rectangle_int_int(int width, int height) {"); addCode(rectConst, " Rectangle * self = (Rectangle*)malloc(sizeof(Rectangle));"); addCode(rectConst, " self->w = width;"); addCode(rectConst, " self->h = height;"); addCode(rectConst, " return self;"); addCode(rectConst, "}"); addSymbol(rect, CreateObject("w", "w", 0, Variable, "int")); addSymbol(rect, CreateObject("h", "h", 0, Variable, "int")); addSymbol(rect, rectConst); addCode(rect, "typedef struct {"); addCode(rect, " BaseType parent;"); addCode(rect, " int w;"); addCode(rect, " int h;"); addCode(rect, "} Rectangle;"); addSymbol(root, basetype); addSymbol(root, rect); addSymbol(root, subexpr); printTree(root, 0); return 0; }
int main( int argc, char * argv[] ) { TreeNode * syntaxTree; char pgm[120]; /* source code file name */ hash_new(&h); if (argc < 2) { fprintf(stderr,"usage: %s <filename>\n",argv[0]); exit(1); } if (argc == 3) { if(strcmp(argv[2], "-a") == 0) { TraceScan = FALSE; TraceAnalyze = FALSE; } else if(strcmp(argv[2], "-s") == 0) { TraceScan = FALSE; TraceParse = FALSE; } } strcpy(pgm,argv[1]) ; if (strchr (pgm, '.') == NULL) strcat(pgm,".cm"); source = fopen(pgm,"r"); if (source==NULL) { fprintf(stderr,"File %s not found\n",pgm); exit(1); } listing = stdout; /* send listing to screen */ fprintf(listing,"\nC Minus compilation: %s\n",pgm); #if NO_PARSE //if(a_flag == 0) while( (ttype=getToken())!= 0 ) printToken( ttype, tokenString ); #else syntaxTree = parse(); if (TraceParse) { fprintf(listing,"\nSyntax tree:\n"); printTree(syntaxTree); } if(TraceAnalyze) { fprintf(listing, "\nSymbol Table:\n"); print_hash(h); } list_kill(l); hash_kill(&h); #endif fclose(source); return 0; }
//print output of a line void printOutput(int line){ int i; for(i = 0; i < preds_lines[line]; i++){ if(negative[line][i]) printf("-"); printTree(predicates[line][i] -> childs[0]); if(i != preds_lines[line] - 1) printf(" | "); } printf("\n"); }
// a function to print the tree void printTree( rootNodePtr r, nodePtr c ) { size_t i; PRINTF("node: %p\n", (void *) c); if( c->index != NULL) { for( i=0; i < c->indexUsed; i++) PRINTF("%d ", (int) c->index[i]); } PRINTF("\n\tleft: %p right %p (split = %f) \n", (void *) c->left, (void*) c->right, c->split ); PRINTF("\n"); if( c->left ) { PRINTF("left "); printTree( r, c->left); } if( c->right ) { PRINTF("right "); printTree( r, c->right); } }
void testIsBST() { struct node* rootNode = insert(NULL,5); rootNode = insert(rootNode,2); rootNode = insert(rootNode,7); rootNode = insert(rootNode,1); //rootNode->left = insert(rootNode->left,6); printTree(rootNode); if(isBST(rootNode) == 1) printf("Given tree is a BST \n"); else printf("Given tree is not a BST \n"); }
int main(){ Node *R = NULL; R = insertNode(R,0); R = insertNode(R,1); R = insertNode(R,5); R = insertNode(R,2); R = insertNode(R,7); R = insertNode(R,8); R = insertNode(R,-1); R = insertNode(R,99); printf("\n\n"); printTree(R); R = removeNode(R,5); printf("\n\n"); printTree(R); R = removeNode(R,4); printf("\n\n"); printTree(R); return 0; }
int main(void){ Node* root = nullptr; root = insert(root, 4); printTree(root); root = insert(root, 10); root = insert(root, 20); root = insert(root, 30); root = insert(root, 40); root = insert(root, 25); root = insert(root, 28); root = insert(root, 2); root = insert(root, 42); root = remove(root, 4); printTree(root); printInfo(root); // add your own tests here return 0; }
void printTree(struct TokenStruct *Token, int indents) { int i; for(i = 0; i < indents; i++) { printf(" "); } printf("Rule: %ls | Symbol: %ls | Data: %ls\n", Grammar.RuleArray[Token->ReductionRule].Description, Grammar.SymbolArray[Token->Symbol].Name, Token->Data); for(i = 0; i < Grammar.RuleArray[Token->ReductionRule].SymbolsCount; i++) { printTree(Token->Tokens[i],indents+1); } }
int main() { TreeNode *p = createTreeNode(0); strcpy(p->symbol, "TYPE"); strcpy(p->text, "int"); TreeNode *q = createTreeNode(0); strcpy(q->symbol, "INT"); q->intVal = 15; TreeNode *r = createTreeNode(2, p, q); printTree(r, 0); deleteTree(r); return 0; }
int main() { int n; scanf("%d",&n); node* root = NULL; int elem,i; for(i=0; i<n; i++) { scanf("%d",&elem); if(root == NULL) root = createNode(elem); else insertInTree(root, elem); } printf("Printing Tree:\n"); printTree(root); printf("\n"); printf("After Reversal called:\n"); sumTree(root); printTree(root); return 0; }