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.

Programs Questions and Answers



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

    Input : ,   Output :

  • 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. Write a program to sort the elements of the tree

    Input : ,   Output :

  • 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. Write a program to convert the tree into its mirror

    Input : ,   Output :

  • 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. Write a program to find two given trees are identical or not

    Input : ,   Output :

  • 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. Write a program to find the number of elements present in the tree

    Input : ,   Output :

  • 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. Write a program to print all leaf nodes of a tree

    Input : ,   Output :

  • 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. Write a program to delete the given tree

    Input : ,   Output :

  • 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. Write a program to traverse the tree in inorder without using recursion

    Input : ,   Output :

  • 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. Write a program to check whether the given tree is balanced or not

    Input : ,   Output :

  • 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. Write a program to enter the string remove the blank spaces from the string.

    Input : ,   Output :

  • 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