/* Driver program to test above functions*/
int main()
{
/* 6
/ \
10 2
/ \ / \
1 3 7 12
10 and 2 are swapped
*/
struct node *root = newNode(6);
root->left = newNode(10);
root->right = newNode(2);
root->left->left = newNode(1);
root->left->right = newNode(3);
root->right->right = newNode(12);
root->right->left = newNode(7);
printf("Inorder Traversal of the original tree \n");
printInorder(root);
correctBST(root);
printf("\nInorder Traversal of the fixed tree \n");
printInorder(root);
return 0;
}
void printInorder(node *root){
if(root != 0){
printInorder(root->left);
printf("%d\n", root->key);
printInorder(root->right);
}
}
/* Driver program to test above functions*/
int main()
{
/* Create following tree as first balanced BST
100
/ \
50 300
/ \
20 70
*/
struct node *root1 = newNode(100);
root1->left = newNode(50);
root1->right = newNode(300);
root1->left->left = newNode(20);
root1->left->right = newNode(70);
printInorder(root1);
/* Create following tree as second balanced BST
80
/ \
40 120
*/
struct node *root2 = newNode(80);
root2->left = newNode(40);
root2->right = newNode(120);
printInorder(root2);
struct node *mergedTree = mergeTrees(root1, root2, 5, 3);
printf ("Following is Inorder traversal of the merged tree \n");
printInorder(mergedTree);
return 0;
}
void printInorder(struct node* root){
if(root == NULL){
return;
}
printInorder(root->left);
printf(" %d ", root->data);
printInorder(root->right);
}
void printInorder (struct node* node)
{
if (node == NULL)
return;
printInorder(node->left);
printf("%d ", node->data);
printInorder(node->right);
}
void BinarySearchTree::printInorder(Node *node) {
if (node == NULL) {
return;
}
printInorder(node->left);
print(node);
printInorder(node->right);
}
// Print the tree in-order
void printInorder(struct node *p)
{
if(p != NULL)
{
printInorder(p->left);
printf("%d %s\n", p->count, p->word);
printInorder(p->right);
}
} // end printInorder
void BST<ItemType>::printInorder(TreeNode<ItemType>*n,ofstream &file)
{
if(n == NULL) return;
printInorder(n->left,file);
file << n->element << " ";
printInorder(n->right,file);
}
/* print the tree inorder */
void printInorder(struct avl_node *node)
{
if (node == NULL)
return;
/* process left node */
printInorder(node->left);
/* process root */
printf("%d ", node->key);
/* process right node */
printInorder(node->right);
}
void printInorder(node * tree)
{
if (tree == NULL)
return;
printInorder(TLEFT);
if (tree->split=='-')
printf("(%le,%le)",tree->width,tree->height);
else
printf(("%c"),tree->split);
printInorder(TRIGHT);
}
/**
* A utility function to print inorder traversal of a given binary tree
*/
void printInorder(struct node* node)
{
if (node == NULL)
return;
/* first recur on left child */
printInorder(node->left);
printf("%d ", node->data);
/* now recur on right child */
printInorder(node->right);
}
/* Utility function to print inorder traversal of Binary Tree */
void printInorder (struct node* node)
{
if (node == NULL)
return;
/* first recur on left child */
printInorder (node->left);
/* then print the val of node */
printf("%d ", node->val);
/* now recur on right child */
printInorder (node->right);
}
/*
in order traversal of binary tree
*/
void printInorder(struct binaryTreeNode *node)
{
if (node == NULL)
return;
//first recur on left subtree
printInorder(node->left);
//then deal with the node
printf("%d ", node->data);
//recur on right subtree
printInorder(node->right);
}
int main(int argc, char* argv[])
{
node *root;
root = NULL;
int i;
if(argc > 1)
{
for(i = 1; i < argc; i++)
{
root = addNode(root, argv[i]);
}
printInorder(root);
}
else
printf("%s\n", "no word");
return 0;
} // end main()
/* Driver function to test above functions */
int main()
{
struct node *root = NULL;
int x;
/* Constructing tree given in the above figure */
root = newNode(10);
root->left = newNode(-2);
root->right = newNode(6);
root->left->left = newNode(8);
root->left->right = newNode(-4);
root->right->left = newNode(7);
root->right->right = newNode(5);
root->left->left->left = newNode(1);
//root->left->left->right = newNode(2);
//root->left->right->left = newNode(3);
//root->left->right->right = newNode(4);
toSumTree(root);
// Print inorder traversal of the converted tree to test result of toSumTree()
printf("Inorder Traversal of the resultant tree is: \n");
printInorder(root);
getchar();
return 0;
}
int main(){
node* root = NULL;
root = insert(root, 6);
root = insert(root, -13);
root = insert(root, 14);
root = insert(root, -8);
root = insert(root, 15);
root = insert(root, 13);
root = insert(root, 7);
cout << "Inorder traversal of the given tree is: ";
printInorder(root);
removeOutsideRange(root, -10, 13);
cout << "\nInorder traversal of the modified tree is: ";
printInorder(root);
getchar();
}
int main(){
int k = 4;
node *root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
root->left->left->left = newNode(7);
root->right->right = newNode(6);
root->right->right->left = newNode(8);
cout << "Inorder Traversal of Original tree" << endl;
printInorder(root);
cout << endl;
cout << "Inorder Traversal of Modified tree" << endl;
node *res = removeShortPathNodes(root, 1, k);
printInorder(res);
return 0;
}
int main(){
node *root = newNode(50);
root->left = newNode(7);
root->right = newNode(2);
root->left->left = newNode(3);
root->left->right = newNode(5);
root->right->left = newNode(1);
root->right->right = newNode(30);
printf("\n Inorder traversal before conversion ");
printInorder(root);
convertTree(root);
printf("\n Inorder traversal after conversion ");
printInorder(root);
return 0;
}
int main(){
int pre[] = {1, 2, 4, 8, 9, 5, 3, 6, 7};
int post[] = {8, 9, 4, 5, 2, 6, 7, 3, 1};
int size = sizeof( pre ) / sizeof(int);
int preStart = 0;
struct node *root = constructTree(pre, post, 0, size-1, &preStart);
printf("Inorder traversal of the constructed tree: \n");
printInorder(root);
return 0;
}
// Driver program to test above function
int main()
{
/* Create following BST
5
/ \
2 13 */
node *root = newNode(5);
root->left = newNode(2);
root->right = newNode(13);
printf(" Inorder traversal of the given tree\n");
printInorder(root);
addGreater(root);
printf("\n Inorder traversal of the modified tree\n");
printInorder(root);
return 0;
}
// driver program to test indenticalTrees function
int main()
{
char in[] = {'D', 'B', 'E', 'A', 'F', 'C'};
char pre[] = {'A', 'B', 'D', 'E', 'C', 'F'};
int len = sizeof(in)/sizeof(in[0]);
struct node *root = buildTree(in, pre, 0, len - 1);
/* Let us test the built tree by printing Insorder traversal */
printf("\n Inorder traversal of the constructed tree is \n");
printInorder(root);
getchar();
}
int main ()
{
int pre[] = {10, 5, 1, 7, 40, 50};
int size = sizeof( pre ) / sizeof( pre[0] );
struct node *root = constructTree(pre, size);
printf(" Inorder traversal of the constructed tree: \n");
printInorder(root);
return 0;
}
int main ()
{
int pre[] = {1,7,5,40,10};
// int size = sizeof( pre ) / sizeof( pre[0] );
struct node *root = BuildTree(pre,0,4);
printf("Inorder traversal of the constructed tree: \n");
printInorder(root);
return 0;
}
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 main(int argc, char *argv[]){
//check command line arguments
if(argc != 2){
printf("usage: ./a.out <input_filename>");
exit(0);
}
//open the file
FILE* input = fopen(argv[1],"r");
if(input == NULL){
printf("File not found");
exit(0);
}
bst* root = NULL;
int i = 0;
int size = 0;
fscanf(input,"%d",&size);
int *a = (int *)malloc(sizeof(int)*size);//create the array
for(i=0;i<size;i++){
fscanf(input,"%d",&a[i]);
}
close(input); //close file
//printout the different ways
printf("Creating Binary Search Tree\n");
root = createBST(a,size);
printf("In-Order traversal: ");
printInorder(root);
printf("\nPre-Order traversal: ");
printPreorder(root);
printf("\nPost-Order traversal: ");
printPostorder(root);
printf("\n\nMinimum Height BST\n");
sort(a,size);
root = createMinBST(a,0,size-1);
printTree(root);
free(a); //free mem
return 0;
}
int main(int argc, char **argv)
{
if(argc < 2)
{
printf("usage: %s <input_filename>/n", argv[0]);
return;
}
FILE* input = fopen(argv[1], "r");
if (input == NULL)
return;
int i, size;
fscanf(input, "%d", &size);
int array[size];
for(i=0; i<size; i++)
fscanf(input, "%d", &array[i]);
//Creates Binary Tree
printf("Creating Binary Tree...\n");
bst* root = createBST(array, size);
//Printing Inorder Traversal
printf("Inorder Traversal: ");
printInorder(root);
printf("\n");
//Printing Pre-order Traversal
printf("Pre-Order Traversal: ");
printPreorder(root);
printf("\n");
//Printing Postorder Traversal
printf("Postorder Traversal: ");
printPostorder(root);
printf("\n");
//Printing the Binary Tree
printf("\nMinimum Height BST\n");
sort(array, size);
root = createMinBST(array, array[0], array[size-1]);
printTree(root);
fclose(input);
free(root);
return 0;
}
int main(){
node *root = newNode(10);
root->left = newNode(12);
root->right = newNode(15);
root->left->left = newNode(25);
root->left->right = newNode(30);
root->right->left = newNode(36);
printf("\n\t\tInorder Tree Traversal\n\n");
printInorder(root);
struct node *head = BTToDLL(root);
printf("\n\n\t\tDLL Traversal\n\n");
printList(head);
}
int main(){
LNode* head = NULL;
push(&head, 36); /* Last node of Linked List */
push(&head, 30);
push(&head, 25);
push(&head, 15);
push(&head, 12);
push(&head, 10); /* First node of Linked List */
node *root;
queue<node*> q;
convertList2Binary(head, &root, q);
cout << "Inorder Traversal of the constructed Binary Tree is: \n";
printInorder(root);
return 0;
}
int main(int argc, char** argv){
node *root = NULL;
insert(5, &root);
insert(10, &root);
insert(8, &root);
insert(3, &root);
insert(4, &root);
printPreorder(root);
printInorder(root);
printPostorder(root);
printf("%d was found\n", (search(8, root)->key));
destroyTree(root);
}
int main() {
node *root;
node *tmp;
//int i;
root = NULL;
//insert nodes
insert(&root, 9);
insert(&root, 4);
insert(&root, 15);
insert(&root, 6);
insert(&root, 12);
insert(&root, 17);
insert(&root, 2);
//Printing nodes of tree
printf("Pre Order Display\n");
printPreorder(root);
printf("In Order Display\n");
printInorder(root);
printf("Post Order Display\n");
printPostorder(root);
// Search node into tree
tmp = searchTree(&root, 4);
if (tmp)
{
printf("Searched node=%d\n", tmp->data);
}
else
{
printf("Data Not found in tree.\n");
}
//Deleting all nodes of tree
deleteTree(root);
return 0;
}
