41 / 348

Write a program to traverse the tree in preorder inorder and postorder

Input : NA

Output : NA

|  Trees | | To Reading List | |  Fresher
``` ```
#include <stdio.h>#include <stdlib.h>/* A binary tree node has data, pointer to left childand a pointer to right child */struct node{    int data;    struct node* left;    struct node* right;};/* Helper function that allocates a new node with thegiven data and NULL left and right pointers. */struct node* newNode(int data){    struct node* node = (struct node*)    malloc(sizeof(struct node));    node->data = data;    node->left = NULL;    node->right = NULL;    return(node);}/* Given a binary tree, print its nodes according to the"bottom-up" postorder traversal. */void printPostorder(struct node* node){    if (node == NULL)        return;    // first recur on left subtree    printPostorder(node->left);    // then recur on right subtree    printPostorder(node->right);    // now deal with the node    printf("%d ", node->data);}/* Given a binary tree, print its nodes in inorder*/void printInorder(struct node* node){    if (node == NULL)        return;    /* first recur on left child */    printInorder(node->left);    /* then print the data of node */    printf("%d ", node->data);     /* now recur on right child */    printInorder(node->right);}/* Given a binary tree, print its nodes in preorder*/void printPreorder(struct node* node){    if (node == NULL)
``````

Tags:No Tags on this question yet!

42 / 348

Write a program to sort the elements of the tree

Input : NA

Output : NA

|  Trees | | To Reading List | |  Fresher
``` ```
#include<bits/stdc++.h>using namespace std;struct Node{    int key;    struct Node *left, *right;};/* A utility function to create a new BST Node*/struct Node *newNode(int item){    struct Node *temp = new Node;    temp->key = item;    temp->left = temp->right = NULL;    return temp;}/* Stores inoder traversal of the BST*//* in arr[]*/void storeSorted(Node *root, int arr[], int &i){    if (root != NULL)    {        storeSorted(root->left, arr, i);        arr[i++] = root->key;        storeSorted(root->right, arr, i);    }}/* A utility function to insert a newNode with given key in BST */Node* insert(Node* node, int key){    /* If the tree is empty, return a new Node */    if (node == NULL) return newNode(key);    /* Otherwise, recur down the tree */    if (key < node->key)        node->left = insert(node->left, key);    else if (key > node->key)        node->right = insert(node->right, key);    /* return the (unchanged) Node pointer */    return node;}/* This function sorts arr[0..n-1] using Tree Sortvoid treeSort(int arr[], int n){    struct Node *root = NULL;    /* Construct the BST    root = insert(root, arr);    for (int i=1; i<n; i++)        insert(root, arr[i]);    /* Store inoder traversal of the BST    /* in arr[]    int i = 0;    storeSorted(root, arr, i);}/* Driver Program to test above functionsint main(){    /*create input array*/    int arr[] = {5, 4, 7, 2, 11};    int n = sizeof(arr)/sizeof(arr);    treeSort(arr, n);    cout << "Sorted Array : ";    for (int i=0; i<n; i++)    cout << arr[i] << " ";    return 0;}
``````

Tags:No Tags on this question yet!

43 / 348

Write a program to convert the tree into its mirror

Input : NA

Output : NA

|  Trees | | To Reading List | |  Fresher
``` ```
#include<stdio.h>
#include<stdlib.h>

/* A binary tree node has data, pointer to left child
and a pointer to right child */
struct node
{
int data;
struct node* left;
struct node* right;
};

/* Helper function that allocates a new node with the
given data and NULL left and right pointers. */
struct node* newNode(int data)

{
struct node* node = (struct node*)malloc(sizeof(struct node));
node->data = data;
node->left = NULL;
node->right = NULL;

return(node);
}

void mirror(struct node* node)
{
if (node==NULL)
return;
else
{
struct node* temp;

/* do the subtrees */
mirror(node->left);
mirror(node->right);

/* swap the pointers in this node */
temp     = node->left;
node->left = node->right;
node->right = temp;
}
}

/* Helper function to test mirror(). Given a binary
search tree, print out its data elements in
increasing sorted order.*/
void inOrder(struct node* node)
{
if (node == NULL)
return;

inOrder(node->left);
printf("%d ", node->data);

inOrder(node->right);
}

/* Driver program to test mirror() */
int main()
{
struct node *root = newNode(1);
root->left     = newNode(2);
root->right     = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);

/* Print inorder traversal of the input tree */
printf("\n Inorder traversal of the constructed tree is \n");
inOrder(root);

/* Convert tree to its mirror */
mirror(root);

/* Print inorder traversal of the mirror tree */
printf("\n Inorder traversal of the mirror tree is \n");
inOrder(root);

getchar();
return 0;
}
``````

Tags:No Tags on this question yet!

44 / 348

Write a program to find two given trees are identical or not

Input : NA

Output : NA

|  Trees | | To Reading List | |  Fresher
``` ```
#include <stdio.h>#include <stdlib.h>/* A binary tree node has data, pointer to left childand a pointer to right child */struct node{    int data;    struct node* left;    struct node* right;};/* Helper function that allocates a new node with thegiven data and NULL left and right pointers. */struct node* newNode(int data){    struct node* node = (struct node*)malloc(sizeof(struct node));    node->data = data;    node->left = NULL;    node->right = NULL;    return(node);}/* Given two trees, return true if they arestructurally identical */int identicalTrees(struct node* a, struct node* b){    /*1. both empty */    if (a==NULL && b==NULL)        return 1;    /* 2. both non-empty -> compare them */    if (a!=NULL && b!=NULL)    {        return        (            a->data == b->data &&            identicalTrees(a->left, b->left) &&            identicalTrees(a->right, b->right)        );    }        /* 3. one empty, one not -> false */    return 0;} /* Driver program to test identicalTrees function*/int main(){    struct node *root1 = newNode(1);    struct node *root2 = newNode(1);    root1->left = newNode(2);    root1->right = newNode(3);    root1->left->left = newNode(4);    root1->left->right = newNode(5);     root2->left = newNode(2);    root2->right = newNode(3);    root2->left->left = newNode(4);    root2->left->right = newNode(5);     if(identicalTrees(root1, root2))        printf("Both tree are identical.");    else        printf("Trees are not identical.");    getchar();return 0;}
``````

Tags:No Tags on this question yet!

45 / 348

Write a program to find the number of elements present in the tree

Input : NA

Output : NA

|  Trees | | To Reading List | |  Fresher
``` ```
``````

Tags:No Tags on this question yet!

46 / 348

Write a program to print all leaf nodes of a tree

Input : NA

Output : NA

|  Trees | | To Reading List | |  Fresher
``` ```
#include <stdio.h>#include <stdlib.h>/* A binary tree node has data, pointer to left child and a pointer to right child */struct node {    int data;    struct node* left;    struct node* right;};/* Function to get the count of leaf nodes in a binary tree*/unsigned int getLeafCount(struct node* node){if(node == NULL)         return 0;if(node->left == NULL && node->right==NULL)         return 1;         else    return getLeafCount(node->left)+        getLeafCount(node->right);     }/* Helper function that allocates a new node with thegiven data and NULL left and right pointers. */struct node* newNode(int data) {struct node* node = (struct node*)malloc(sizeof(struct node));node->data = data;node->left = NULL;node->right = NULL;return(node);}/*Driver program to test above functions*/int main(){/*create a tree*/struct node *root = newNode(1);root->left     = newNode(2);root->right     = newNode(3);root->left->left = newNode(4);root->left->right = newNode(5); /*get leaf count of the above created tree*/printf("Leaf count of the tree is %d", getLeafCount(root));getchar();return 0;}
``````

Tags:No Tags on this question yet!

47 / 348

Write a program to delete the given tree

Input : NA

Output : NA

|  Trees | | To Reading List | |  Fresher
``` ```
#include<stdio.h>#include<stdlib.h>/* A binary tree node has data, pointer to left child and a pointer to right child */struct node {    int data;    struct node* left;    struct node* right;};/* Helper function that allocates a new node with thegiven data and NULL left and right pointers. */struct node* newNode(int data) {    struct node* node = (struct node*)malloc(sizeof(struct node));    node->data = data;    node->left = NULL;    node->right = NULL;     return(node);}/* This function traverses tree in post order to     to delete each and every node of the tree */void deleteTree(struct node* node) {    if (node == NULL) return;    /* first delete both subtrees */    deleteTree(node->left);    deleteTree(node->right);    /* then delete the node */    printf("\n Deleting node: %d", node->data);    free(node);} /* Driver program to test deleteTree function*/int main(){    struct node *root = newNode(1);     root->left         = newNode(2);    root->right         = newNode(3);    root->left->left     = newNode(4);    root->left->right = newNode(5);     deleteTree(root);     root = NULL;    printf("\n Tree deleted ");    getchar();    return 0;}
``````

Tags:No Tags on this question yet!

48 / 348

Write a program to traverse the tree in inorder without using recursion

Input : NA

Output : NA

|  Trees | | To Reading List | |  Fresher
``` ```
#include<stdio.h>#include<stdlib.h>#define bool int/* A binary tree tNode has data, pointer to left childand a pointer to right child */struct tNode{int data;struct tNode* left;struct tNode* right;};/* Structure of a stack node. Linked List implementation is used for stack. A stack node contains a pointer to tree node and a pointer to next stack node */struct sNode{struct tNode *t;struct sNode *next;};/* Stack related functions */void push(struct sNode** top_ref, struct tNode *t);struct tNode *pop(struct sNode** top_ref);bool isEmpty(struct sNode *top);/* Iterative function for inorder tree traversal */void inOrder(struct tNode *root){/* set current to root of binary tree */struct tNode *current = root;struct sNode *s = NULL; /* Initialize stack s */bool done = 0;while (!done){    /* Reach the left most tNode of the current tNode */    if(current != NULL)    {    /* place pointer to a tree node on the stack before traversing         the node's left subtree */    push(&s, current);                                                 current = current->left;     }            /* backtrack from the empty subtree and visit the tNode     at the top of the stack; however, if the stack is empty,    you are done */    else                                                                {    if (!isEmpty(s))    {        current = pop(&s);        printf("%d ", current->data);        /* we have visited the node and its left subtree.        Now, it's right subtree's turn */        current = current->right;    }    else        done = 1;     }} /* end of while */}     /* UTILITY FUNCTIONS *//* Function to push an item to sNode*/void push(struct sNode** top_ref, struct tNode *t){/* allocate tNode */struct sNode* new_tNode =(struct sNode*) malloc(sizeof(struct sNode));if(new_tNode == NULL){    printf("Stack Overflow \n");    getchar();    exit(0);}         /* put in the data */new_tNode->t = t;/* link the old list off the new tNode */new_tNode->next = (*top_ref); /* move the head to point to the new tNode */(*top_ref) = new_tNode;}/* The function returns true if stack is empty, otherwise false */bool isEmpty(struct sNode *top){return (top == NULL)? 1 : 0;} /* Function to pop an item from stack*/struct tNode *pop(struct sNode** top_ref){struct tNode *res;struct sNode *top;/*If sNode is empty then error */if(isEmpty(*top_ref)){    printf("Stack Underflow \n");    getchar();    exit(0);}else{    top = *top_ref;    res = top->t;    *top_ref = top->next;    free(top);    return res;}}/* Helper function that allocates a new tNode with thegiven data and NULL left and right pointers. */struct tNode* newtNode(int data){struct tNode* tNode = (struct tNode*)malloc(sizeof(struct tNode));tNode->data = data;tNode->left = NULL;tNode->right = NULL;return(tNode);}/* Driver program to test above functions*/int main(){/* Constructed binary tree is             1        / \           2   3          / \         4     5*/struct tNode *root = newtNode(1);root->left     = newtNode(2);root->right     = newtNode(3);root->left->left = newtNode(4);root->left->right = newtNode(5); inOrder(root);getchar();return 0;}
``````

Tags:No Tags on this question yet!

49 / 348

Write a program to check whether the given tree is balanced or not

Input : NA

Output : NA

|  Trees | | To Reading List | |  Fresher
``` ```
#include<stdio.h>#include<stdlib.h>#define bool int/* A binary tree tNode has data, pointer to left childand a pointer to right child */struct tNode{int data;struct tNode* left;struct tNode* right;};/* Structure of a stack node. Linked List implementation is used for stack. A stack node contains a pointer to tree node and a pointer to next stack node */struct sNode{struct tNode *t;struct sNode *next;};/* Stack related functions */void push(struct sNode** top_ref, struct tNode *t);struct tNode *pop(struct sNode** top_ref);bool isEmpty(struct sNode *top);/* Iterative function for inorder tree traversal */void inOrder(struct tNode *root){/* set current to root of binary tree */struct tNode *current = root;struct sNode *s = NULL; /* Initialize stack s */bool done = 0;while (!done){    /* Reach the left most tNode of the current tNode */    if(current != NULL)    {    /* place pointer to a tree node on the stack before traversing         the node's left subtree */    push(&s, current);                                                 current = current->left;     }            /* backtrack from the empty subtree and visit the tNode     at the top of the stack; however, if the stack is empty,    you are done */    else                                                                {    if (!isEmpty(s))    {        current = pop(&s);        printf("%d ", current->data);        /* we have visited the node and its left subtree.        Now, it's right subtree's turn */        current = current->right;    }    else        done = 1;     }} /* end of while */}     /* UTILITY FUNCTIONS *//* Function to push an item to sNode*/void push(struct sNode** top_ref, struct tNode *t){/* allocate tNode */struct sNode* new_tNode =            (struct sNode*) malloc(sizeof(struct sNode));if(new_tNode == NULL){    printf("Stack Overflow \n");    getchar();    exit(0);}         /* put in the data */new_tNode->t = t;/* link the old list off the new tNode */new_tNode->next = (*top_ref); /* move the head to point to the new tNode */(*top_ref) = new_tNode;}/* The function returns true if stack is empty, otherwise false */bool isEmpty(struct sNode *top){return (top == NULL)? 1 : 0;} /* Function to pop an item from stack*/struct tNode *pop(struct sNode** top_ref){struct tNode *res;struct sNode *top;/*If sNode is empty then error */if(isEmpty(*top_ref)){    printf("Stack Underflow \n");    getchar();    exit(0);}else{    top = *top_ref;    res = top->t;    *top_ref = top->next;    free(top);    return res;}}/* Helper function that allocates a new tNode with thegiven data and NULL left and right pointers. */struct tNode* newtNode(int data){struct tNode* tNode = (struct tNode*)                    malloc(sizeof(struct tNode));tNode->data = data;tNode->left = NULL;tNode->right = NULL;return(tNode);}/* Driver program to test above functions*/int main(){/* Constructed binary tree is            1        / \        2     3    / \    4     5*/struct tNode *root = newtNode(1);root->left     = newtNode(2);root->right     = newtNode(3);root->left->left = newtNode(4);root->left->right = newtNode(5); inOrder(root);getchar();return 0;}
``````

Tags:No Tags on this question yet!

50 / 348

Write a program to enter the string remove the blank spaces from the string.

Input : NA

Output : NA

|  Strings | | To Reading List | |  Fresher
``` ```