Note 1

Take Note:

Take a note while surfing.





Note With Ink

Give your Note a Colorful Tag.




Easy to Access

Stay on same information and in Sync wherever you are.

Note 2

Take Note:

Organize your information,It may take Shape.





Think With Ink

Differ your Content by Color.




Easy to Access

Easy to pull up your content from anywhere anytime.

Note 3

Take Note:

Don't Let information to miss,Because it take shape





Note With Ink

Simple an Easy Way to take a note.




Easy to Access

Get the same in next visit.


Please wait...

  Take Quiz (Monsoon) Beta Version !!
  Do You have Qs. in your Mind ??? Ask it as Qs. or MCQs or create it as polling Live Now !!

Programs Questions and Answers



    41 / 348

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

    Input : NA


    Output : NA

    View Answer |  Trees |  Discuss in Forum | Add to Reading List To Reading List | Asked In |  Fresher
    Answer In: C  
     
    #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);
    }

    /* 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

    View Answer |  Trees |  Discuss in Forum | Add to Reading List To Reading List | Asked In |  Fresher
    Answer In: C   C++  
     
    #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 new
    Node 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 Sort
    void treeSort(int arr[], int n)
    {
        struct Node *root = NULL;

        /* Construct the BST
        root = insert(root, arr[0]);
        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 functions
    int main()
    {
        /*create input array*/
        int arr[] = {5, 4, 7, 2, 11};
        int n = sizeof(arr)/sizeof(arr[0]);
        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

    View Answer |  Trees |  Discuss in Forum | Add to Reading List To Reading List | Asked In |  Fresher
    Answer In: C  
     
    #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

    View Answer |  Trees |  Discuss in Forum | Add to Reading List To Reading List | Asked In |  Fresher
    Answer In: C  
     
    #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);
    }
    /* Given two trees, return true if they are
    structurally 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

    View Answer |  Trees |  Discuss in Forum | Add to Reading List To Reading List | Asked In |  Fresher
    Answer In: C  
     
    #include <stdio.h>
    #include <stdlib.h> 
    /*Structure of node */
    struct btnode 
    {
        int value;
        struct btnode *l;
        struct btnode *r;
    };
    void createbinary();
    void preorder(node *);
    int count(node*);
    node* add(int); 
    typedef struct btnode node;
    node *ptr, *root = NULL;
    int  main()
    {
        int c; 
        createbinary();
        preorder(root);
        c = count(root);
        printf("\nNumber of nodes in binary tree are:%d\n", c);
    }
    /*
      constructing the following binary tree
          50
          / \
         20 30
          / \ 
         70 80
         / \  \
        10 40 60
     */    
    void createbinary()
    {
        root = add(50);
        root->l = add(20);
        root->r = add(30);
        root->l->l = add(70);
        root->l->r = add(80);
        root->l->l->l = add(10);
        root->l->l->r = add(40);
        root->l->r->r = add(60);
    }
     
    /*Add the node to binary tree*/
    node* add(int val)
    {
        ptr = (node*)malloc(sizeof(node));
        if (ptr == NULL)
        {
            printf("Memory was not allocated");
            return;
        }
        ptr->value = val;
        ptr->l = NULL;
        ptr->r = NULL;
        return ptr;
    }
     
    /*counting the number of nodes in a tree*/
    int count(node *n)
    {
        int c = 1;
     
        if (n == NULL)
            return 0;
        else
        {
            c += count(n->l);
            c += count(n->r);
            return c;
         }
    }
    /*Displaying the nodes of tree in preorder*/
    void preorder(node *t)
    {
        if (t != NULL)
        {
            printf("%d->", t->value);    
            preorder(t->l);
            preorder(t->r);
        }
     }

    Tags:No Tags on this question yet!

    46 / 348

    Write a program to print all leaf nodes of a tree

    Input : NA


    Output : NA

    View Answer |  Trees |  Discuss in Forum | Add to Reading List To Reading List | Asked In |  Fresher
    Answer In: C  
     
    #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 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);
    }

    /*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

    View Answer |  Trees |  Discuss in Forum | Add to Reading List To Reading List | Asked In |  Fresher
    Answer In: C  
     
    #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);
    }
    /* 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

    View Answer |  Trees |  Discuss in Forum | Add to Reading List To Reading List | Asked In |  Fresher
    Answer In: C  
     
    #include<stdio.h>
    #include<stdlib.h>
    #define bool int
    /* A binary tree tNode has data, pointer to left child
    and 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 the
    given 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

    View Answer |  Trees |  Discuss in Forum | Add to Reading List To Reading List | Asked In |  Fresher
    Answer In: C  
     
    #include<stdio.h>
    #include<stdlib.h>
    #define bool int

    /* A binary tree tNode has data, pointer to left child
    and 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 the
    given 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

    View Answer |  Strings |  Discuss in Forum | Add to Reading List To Reading List | Asked In |  Fresher
    Answer In: C   C++   JAVA   PHP  
     
    class RemoveSpace
    {
    public static void main(String[] args) {
            String s1 ="java is a     Programming language";
            String s2=s1.replaceAll("\\s","");
            System.out.println("Without Space String S2 is:" " " s2);
        }
    }

    Tags:IBM