Helpmestudybro

Print All Nodes of Binary Tree That Do not Have Siblings

admin — Tue, 26 Jan 2021 19:50:17 +0000

“Print All Nodes of Binary Tree That Do not Have Siblings” is one of foremost algorithmic problem asked in a technical interview of product-based companies. Here, we are given a binary tree and our task is to write a program to print all nodes of binary tree that don’t have siblings.

Sibling Nodes: Two Nodes are said to be sibling nodes if the parent node of both nodes is same. Any Node can have at most one sibling. Root node does not have any sibling.

We can solve the following problem both recursively and iteratively. Here, the idea is that for any node (not leaf node), check if it has only one child node or have both child nodes. If only one child node is present, then print that node and continue traversal. If both child nodes are present, then simply continue traversal.

METHOD 1: Recursive Solution

C++ Program to print all nodes of Binary Tree that do not have siblings is as follows:

/* C++ Program to print all nodes of Binary Tree that do not have siblings */
#include
using namespace std;

typedef struct Node
{
    int data;
    struct Node *left;
    struct Node *right;
    Node(int ele)
    {
        data = ele;
        left = NULL;
        right = NULL;
    }
} Node;

/* Function to print all nodes of Binary Tree that don’t have siblings */
void printSingleSiblings(Node *root)
{
    /* Bssic Case: Null Tree */
    if(root == NULL)
    return;
    
    /* If only right child is present, print it and recursively traversel right subtree */
    if(root -> left == NULL && root -> right != NULL)
    {
        cout< right -> data<<" ";
        printSingleSiblings(root -> right);
    }
    
    /* If only left child is present, print it and recursively traversel left subtree */
    else if(root -> left != NULL && root -> right == NULL)
    {
        cout< left -> data<<" ";
        printSingleSiblings(root -> left);
    }
    
    /* If both childs are present, recursively traverse them */
    else
    {
        printSingleSiblings(root -> left);
        printSingleSiblings(root -> right);
    }
}

int main()
{
    /* Creating a Binary trees and inserting some nodes in it */
    Node *root = NULL;
  
    
    root = new Node(1);
    root -> left = new Node(2);
    root -> right = new Node(3);
    root -> left -> left = new Node(4);
    root -> left -> right = new Node(5);
    root -> right -> left = new Node(6);
    root -> right -> right = new Node (7);
    root -> left -> right -> left = new Node(8);
    root -> right -> left -> right = new Node(9);
    
    /* Calling function to print all nodes of Binary Tree that do not have siblings */
    cout<<"Nodes in a tree that don't have siblings are:\n";
    printSingleSiblings(root);
}

OUTPUT:

Nodes in a tree that don't have siblings are:
8 9

METHOD 2: Iterative Solution

C++ Program to print all nodes of Binary Tree that do not have siblings is as follows:

/* C++ Program to print all nodes of Binary Tree that do not have siblings */
#include
using namespace std;

typedef struct Node
{
    int data;
    struct Node *left;
    struct Node *right;
    Node(int ele)
    {
        data = ele;
        left = NULL;
        right = NULL;
    }
} Node;

/* Function to print all nodes of Binary Tree that do not have siblings */
void printSingleSiblings(Node *root)
{
    /* Bssic Case: Null Tree */
    if(root == NULL)
    return;
    
   queue que;
   que.push(root);
   
   while(!que.empty())
   {
       Node *temp = que.front();
       
       que.pop();
       
       if(temp -> left == NULL && temp -> right != NULL)
       {
           cout< right -> data<<" ";
           que.push(temp -> right);
       }
       else if(temp -> left != NULL && temp -> right == NULL)
       {
           cout< left -> data<<" ";
           que.push(temp -> left);
       }
       else if(temp -> left != NULL && temp -> right != NULL)
       {
           que.push(temp -> left);
           que.push(temp -> right);
       }
   }
}

int main()
{
    /* Creating a Binary trees and inserting some nodes in it */
    Node *root = NULL;
  
    
    root = new Node(1);
    root -> left = new Node(2);
    root -> right = new Node(3);
    root -> left -> left = new Node(4);
    root -> left -> right = new Node(5);
    root -> right -> left = new Node(6);
    root -> right -> right = new Node (7);
    root -> left -> right -> left = new Node(8);
    root -> right -> left -> right = new Node(9);
    
    /* Calling function to print all nodes of Binary Tree that do not have siblings */
    cout<<"Nodes in a tree that don't have siblings are:\n";
    printSingleSiblings(root);
}

OUTPUT:

Nodes in a tree that don't have siblings are:
8 9

Determine if two binary trees are identical or not

admin — Tue, 26 Jan 2021 19:32:26 +0000

“Determine if two binary trees are identical or not” is a basic problem of tree data structure. Here, we are given two binary trees and our task is to write a program to determine if given two binary trees are identical or not.

We can solve this problem both recursively and iteratively. The basic idea in both the solution is to check whether root node of first tree is equal to root node of second tree. If value of root node of both trees is equal then, we recursively or iteratively traverse the left subtree and right subtree and check whether left subtree of first tree is equal to left subtree of second tree and right subtree of first tree is equal to right subtree of second tree.

If at any point of traversal and comparison, the left and right subtree of first tree is not equal to left and right subtree of second tree, then we return false.

Method 1: Recursive Solution

C++ Program to Determine if two binary trees are identical or not is as follows:

/* C++ Program to determine if two binary trees are identical or not */
#include
using namespace std;

typedef struct Node
{
    int data;
    struct Node *left;
    struct Node *right;
    Node(int ele)
    {
        data = ele;
        left = NULL;
        right = NULL;
    }
} Node;

/* Function to determine if two binary trees are identical or not */
bool checkidentical(Node *root1, Node *root2)
{
    /* Basic Case: Both Trees are empty */
    if(root1 == NULL && root2 == NULL)
    {
        return true;
    }
    
    /* If one tree is empty and other not */
    if(root1 == NULL || root2 == NULL)
    {
        return false;
    }
    
    /*
        If data of nodes are equal, then recursively check left
        subtree and right subtree of both given binary trees
    */
    if(root1 -> data == root2 -> data)
    {
        return checkidentical(root1 -> left, root2 -> left) &&
        checkidentical(root1 -> right, root2 -> right);
    }
    else
    {
        return false;
    }
}

int main()
{
    /* Creating a Binary trees and inserting some nodes in it */
    Node *root1 = NULL;
    Node *root2 = NULL;
    
    root1 = new Node(1);
    root1 -> left = new Node(2);
    root1 -> right = new Node(3);
    root1 -> left -> left = new Node(4);
    root1 -> left -> right = new Node(5);
    root1 -> right -> left = new Node(6);
    root1 -> right -> right = new Node (7);
    root1 -> left -> right -> left = new Node(8);
    root1 -> right -> left -> right = new Node(9);
    
    root2 = new Node(1);
    root2 -> left = new Node(2);
    root2 -> right = new Node(3);
    root2 -> left -> left = new Node(4);
    root2 -> left -> right = new Node(5);
    root2 -> right -> left = new Node(6);
    root2 -> right -> right = new Node (7);
    root2 -> left -> right -> left = new Node(8);
    root2 -> right -> left -> right = new Node(9);
    
    
    /* Calling function to determine if two binary trees are identical or not */
    if(checkidentical(root1, root2) == true)
    {
        cout<<"Given Binary Trees are Identical!!";
    }
    else
    {
        cout<<"Given Binary Tree are not Identical!!";
    }
}

OUTPUT:

Given Binary Trees are Identical!!

Method 2: Iterative Solution

C++ Program to Determine if two binary trees are identical or not is as follows:

/* C++ Program to determine if two binary trees are identical or not */
#include
using namespace std;

typedef struct Node
{
    int data;
    struct Node *left;
    struct Node *right;
    Node(int ele)
    {
        data = ele;
        left = NULL;
        right = NULL;
    }
} Node;

/* Function to determine if two binary trees are identical or not */
bool checkidentical(Node *root1, Node *root2)
{
     /* Basic Case: Both Trees are empty */
    if(root1 == NULL && root2 == NULL)
    {
        return true;
    }
    
    /* If one tree is empty and other not */
    if(root1 == NULL || root2 == NULL)
    {
        return false;
    }
    
    /* Initialize queue and push root into it */
    queue que1;
    queue que2;
    
    que1.push(root1);
    que2.push(root2);
    
    while(!que1.empty() && !que2.empty())
    {
        Node *temp1 = que1.front();
        Node *temp2 = que2.front();
        
        /* 
            If data of both nodes are same, 
            then traverse trees further
        */
        if(temp1 -> data == temp2 -> data)
        {
            que1.pop();
            que2.pop();
            
            /*
                If left child of both tree exists, push it into queue
            */
            if(temp1 -> left && temp2 -> left)
            {
                que1.push(temp1 -> left);
                que2.push(temp2 -> left);
            }
            /*
                If left child of only one tree exists, then return false.
            */
            else if(temp1 -> left || temp2 -> left)
            {
                return false;
            }
            
            /*
                If right child of both tree exists, push it into queue
            */
            if(temp1 -> right && temp2 -> right)
            {
                que1.push(temp1 -> right);
                que2.push(temp2 -> right);
            }
            /*
                If right child of only one tree exists, then return false.
            */
            else if(temp1 -> right || temp2 -> right)
            {
                return false;
            }
        }
        /*
            If data of both nodes are not same, 
            then return false
        */
        else
        {
            return false;
        }
    }
    return true;
}

int main()
{
    /* Creating a Binary trees and inserting some nodes in it */
    Node *root1 = NULL;
    Node *root2 = NULL;
    
    root1 = new Node(1);
    root1 -> left = new Node(2);
    root1 -> right = new Node(3);
    root1 -> left -> left = new Node(4);
    root1 -> left -> right = new Node(5);
    root1 -> right -> left = new Node(6);
    root1 -> right -> right = new Node (7);
    root1 -> left -> right -> left = new Node(8);
    root1 -> right -> left -> right = new Node(9);
    
    root2 = new Node(1);
    root2 -> left = new Node(2);
    root2 -> right = new Node(3);
    root2 -> left -> left = new Node(4);
    root2 -> left -> right = new Node(5);
    root2 -> right -> left = new Node(6);
    root2 -> right -> right = new Node (7);
    root2 -> left -> right -> left = new Node(8);
    root2 -> right -> left -> right = new Node(9);
    
    
    /* Calling function to determine if two binary trees are identical or not */
    if(checkidentical(root1, root2) == true)
    {
        cout<<"Given Binary Trees are Identical!!";
    }
    else
    {
        cout<<"Given Binary Tree are not Identical!!";
    }
}

OUTPUT:

Given Binary Trees are Identical!!

Related Posts:

The post Determine if two binary trees are identical or not appeared first on Helpmestudybro.

Print all Root to Leaf Paths in a Binary Tree

admin — Sun, 24 Jan 2021 19:04:23 +0000

“Print all Root to Leaf Paths in a Binary Tree” is an important algorithmic problem based on tree data. Here, we are given a binary tree and our task is to write a program to print all root to leaf paths in given binary tree.

Here, the idea is to traverse the given binary tree in preorder fashion and push every encountered node in current path from root to leaf in a vector.

If encountered node is leaf node, we will print the whole vector.

After that, pop out current node from vector after left and right subtree are traversed.

C++ Program to print all root to leaf paths in a binary tree is as follows:

/* C++ Program to Print All Root to Leaf Path in a Binary Tree */
#include
using namespace std;

typedef struct Node
{
    int data;
    struct Node *left;
    struct Node *right;
    Node(int ele)
    {
        data = ele;
        left = NULL;
        right = NULL;
    }
} Node;

/* Function to Print All Root to Leaf Path in a Binary Tree */
void printPaths(Node *root, vector &vc)
{
    /* Base Condition: Empty Tree */
    if(root == NULL)
    return;
    
    /* Push Node in current Path Vector */
    vc.push_back(root -> data);
    
    /* If current Node is Leaf Node, we'll print the Path */
    if(root -> left == NULL && root -> right == NULL)
    {
        for(int i = 0; i < vc.size(); i++)
        cout< left, vc);
    printPaths(root -> right, vc);
    
    /* Pop Out Current Node after left and right subtree are done */
    vc.pop_back();
}

/* Function to Print All Root to Leaf Path in a Binary Tree */
void printRootToLeaf(Node *root)
{
    /* Base Condition: Empty Tree */
    if(root == NULL)
    return;
    
    vector vc;
    printPaths(root,vc);
}

int main()
{
    /* Creating a Binary trees and inserting some nodes in it */
    Node *root = NULL;
    
    root = new Node(1);
    root -> left = new Node(2);
    root -> right = new Node(3);
    root -> left -> left = new Node(4);
    root -> left -> right = new Node(5);
    root -> right -> left = new Node(6);
    root -> right -> right = new Node (7);
    root -> left -> right -> left = new Node(8);
    root -> right -> left -> right = new Node(9);
    
    /* Calling function to Print All Root to Leaf Path in a Binary Tree */
    printRootToLeaf(root);
}

OUTPUT:

Related Posts:

The post Print all Root to Leaf Paths in a Binary Tree appeared first on Helpmestudybro.

Convert Binary Tree to its Mirror Tree

admin — Sun, 24 Jan 2021 18:55:24 +0000

“Convert Binary Tree to its Mirror Tree” is a basic problem of tree data structure. Here, we are given a binary tree and our task is to write a program to convert given binary tree to its mirror tree.

Mirror Trees

This is a simple problem and can be solved using various traversal algorithm. Here, we are going to solve the given problem using postorder traversal and level order traversal. In both the traversal, we only need to swap the left and right child.

Method 1: Using Postorder Traversal

C++ Program to convert binary tree to its mirror tree is as follows:

/* C++ Program to Convert Binary Tree to its Mirror Tree */
#include
using namespace std;

typedef struct Node
{
    int data;
    struct Node *left;
    struct Node *right;
    Node(int ele)
    {
        data = ele;
        left = NULL;
        right = NULL;
    }
} Node;

/* Function to Convert Binary Tree to its Mirror Tree */
void convertMirror(Node *root)
{
    /* Base Condition: Empty Tree */
    if(root == NULL)
    return;
    
    convertMirror(root -> left);
    convertMirror(root -> right);
    
    swap(root -> left, root -> right);
}

/* Inorder Traversal */
void inorder(Node *root)
{
    if(root == NULL)
    return;
    
    inorder(root -> left);
    cout< data<<" ";
    inorder(root -> right);
}

int main()
{
    /* Creating a Binary trees and inserting some nodes in it */
    Node *root = NULL;
    
    root = new Node(1);
    root -> left = new Node(2);
    root -> right = new Node(3);
    root -> left -> left = new Node(4);
    root -> left -> right = new Node(5);
    root -> right -> left = new Node(6);
    root -> right -> right = new Node (7);
    root -> left -> right -> left = new Node(8);
    root -> right -> left -> right = new Node(9);
    
    /* Printing Inorder Traversal before converting to Mirror Tree */
    cout<<"Inorder Traversal of Original Tree:\n";
    inorder(root);
    
    /* Calling function to Convert Binary Tree to its Mirror Tree */
    convertMirror(root);
    
    /* Printing Inorder Traversal after converting to Mirror Tree */
    cout<<"\nInorder Traversal of Mirror Tree:\n";
    inorder(root);
}

OUTPUT:

Inorder Traversal of Original Tree:
4 2 8 5 1 6 9 3 7 
Inorder Traversal of Mirror Tree:
7 3 9 6 1 5 8 2 4

Method 2: Using Level Order Traversal

C++ Program to convert binary tree to its mirror tree is as follows:

/* C++ Program to Convert Binary Tree to its Mirror Tree */
#include
using namespace std;

typedef struct Node
{
    int data;
    struct Node *left;
    struct Node *right;
    Node(int ele)
    {
        data = ele;
        left = NULL;
        right = NULL;
    }
} Node;

/* Function to Convert Binary Tree to its Mirror Tree */
void convertMirror(Node *root)
{
    /* Base Condition: Empty Tree */
    if(root == NULL)
    return;
    
    queue qu;
    qu.push(root);
    
    while(!qu.empty())
    {
        Node *curr = qu.front();
        qu.pop();
        
        swap(curr -> left, curr -> right);
        
        if(curr -> left)
        qu.push(curr -> left);
        
        if(curr -> right)
        qu.push(curr -> right);
    }
}

/* Inorder Traversal */
void inorder(Node *root)
{
    if(root == NULL)
    return;
    
    inorder(root -> left);
    cout< data<<" ";
    inorder(root -> right);
}

int main()
{
    /* Creating a Binary trees and inserting some nodes in it */
    Node *root = NULL;
    
    root = new Node(1);
    root -> left = new Node(2);
    root -> right = new Node(3);
    root -> left -> left = new Node(4);
    root -> left -> right = new Node(5);
    root -> right -> left = new Node(6);
    root -> right -> right = new Node (7);
    root -> left -> right -> left = new Node(8);
    root -> right -> left -> right = new Node(9);
    
    /* Printing Inorder Traversal before converting to Mirror Tree */
    cout<<"Inorder Traversal of Original Tree:\n";
    inorder(root);
    
    /* Calling function to Convert Binary Tree to its Mirror Tree */
    convertMirror(root);
    
    /* Printing Inorder Traversal after converting to Mirror Tree */
    cout<<"\nInorder Traversal of Mirror Tree:\n";
    inorder(root);
}

OUTPUT:

Inorder Traversal of Original Tree:
4 2 8 5 1 6 9 3 7 
Inorder Traversal of Mirror Tree:
7 3 9 6 1 5 8 2 4

Related Posts:

The post Convert Binary Tree to its Mirror Tree appeared first on Helpmestudybro.

Check if Binary Tree is Symmetric or Not

admin — Sun, 24 Jan 2021 10:16:24 +0000

“Check if Binary Tree is Symmetric or Not” is a basic problem based on tree data structure. Here, we are given a binary tree and our task is to write a program to check if given binary tree have symmetric structure or not.

A Binary Tree is having symmetric structure if left subtree and right subtree are mirror image of each other, irrespective of node value.

Symmetric Tree

We have already discussed to check if two binary trees are mirror tree of each other or not. Here, also, we will use same technique to check symmetry of tree.

A Binary Tree is Symmetric if it holds following conditions:

Both Left subtree and right subtree are empty or non-empty.
Left Subtree is mirror image of right subtree, irrespective of data.
Right Subtree is mirror image of left subtree, irrespective of data.

C++ Program to Check if Binary Tree is Symmetric or Not is as follows:

/* C++ Program to Check if Binary Tree is Symmetric or Not */
#include
using namespace std;

typedef struct Node
{
    int data;
    struct Node *left;
    struct Node *right;
    Node(int ele)
    {
        data = ele;
        left = NULL;
        right = NULL;
    }
} Node;

/* Function to Check if Binary Tree is Symmetric or Not */
bool checkSymmetry(Node *root1, Node *root2)
{
    /* Base Case1: If both Subtrees are Empty */
    if(root1 == NULL && root2 == NULL)
    return true;
    
    /* Base Case2: If one subtree is empty and other not */
    if(root1 == NULL || root2 == NULL)
    return false;
    
    /*
        If Both are Non-Empty, Recursively compare left subtree 
         with right subtree and vice-versa
    */
    return (root1 != NULL && root2 != NULL) &&
           checkSymmetry(root1 -> left, root2 -> right) &&
           checkSymmetry(root1 -> right,root2 -> left);
}

int main()
{
    /* Creating a Binary trees and inserting some nodes in it */
    Node *root = NULL;
    
    root = new Node(1);
    root -> left = new Node(2);
    root -> right = new Node(3);
    root -> left -> left = new Node(4);
    root -> left -> right = new Node(5);
    root -> right -> left = new Node(6);
    root -> right -> right = new Node (7);
    root -> left -> right -> left = new Node(8);
    root -> right -> left -> right = new Node(9);
    
    /* Calling function to Check if Binary Tree is Symmetric or Not */
    if(checkSymmetry(root -> left, root -> right) == true)
    {
        cout<<"Given Binary Tree is Symmetric Tree!!";
    }
    else
    {
        cout<<"Given Binary Tree is not Symmetric Tree!!";
    }
}

OUTPUT:

Given Binary Tree is Symmetric Tree!!

Related Posts:

The post Check if Binary Tree is Symmetric or Not appeared first on Helpmestudybro.

Delete Binary Tree

admin — Fri, 22 Jan 2021 20:48:00 +0000

“Delete Binary Tree” is an elementary problem based on tree data structure. Here, we are given a binary tree and our task is to delete given binary tree. We need to delete all the nodes and release memory.

If tree needs to be deleted, then, it needs to be traversed first and one-by-one memory of all the nodes must be released. It’s obvious that before deleting any parent node, we need to delete child node. So, for that, postorder traversal can be used, as it will help to delete left child, then right child and in last root node.

C++ Program to Delete Binary Tree is as follows:

/* C++ Program to Delete Binary Tree */
#include
using namespace std;

typedef struct Node
{
    int data;
    struct Node *left;
    struct Node *right;
    Node(int ele)
    {
        data = ele;
        left = NULL;
        right = NULL;
    }
} Node;

/* Function to Delete Binary Tree */
void deleteTree(Node *root)
{
   /* Base Case */
   if(root == NULL)
   return;
   
   deleteTree(root -> left);
   deleteTree(root -> right);
   
   cout<<"Deleting Node with Value "<data<<"\n";
   delete root;
}

int main()
{
    /* Creating a Binary trees and inserting some nodes in it */
    Node *root = NULL;
    
    root = new Node(1);
    root -> left = new Node(2);
    root -> right = new Node(3);
    root -> left -> left = new Node(4);
    root -> left -> right = new Node(5);
    root -> right -> left = new Node(6);
    root -> right -> right = new Node (7);
    root -> left -> right -> left = new Node(8);
    root -> right -> left -> right = new Node(9);
    
    /* Calling function to delete binary tree */
    deleteTree(root);
}

OUTPUT:

Deleting Node with Value 4
Deleting Node with Value 8
Deleting Node with Value 5
Deleting Node with Value 2
Deleting Node with Value 9
Deleting Node with Value 6
Deleting Node with Value 7
Deleting Node with Value 3
Deleting Node with Value 1

Method 2: Deletion using Level Order Traversal

We can delete the given binary tree using level order traversal also. In the previous method, we delete the leaf nodes first and then their parents. But, here, we will delete the tree in root to leaf fashion.

Before deleting any node, we will push the left and right child of it, if exist, into queue.

C++ Program to Delete Binary Tree is as follows:

/* C++ Program to Delete Binary Tree */
#include
using namespace std;

typedef struct Node
{
    int data;
    struct Node *left;
    struct Node *right;
    Node(int ele)
    {
        data = ele;
        left = NULL;
        right = NULL;
    }
} Node;

/* Function to Delete Binary Tree */
void deleteTree(Node *root)
{
   /* Base Case */
   if(root == NULL)
   return;
   
   queue que;
   
   que.push(root);
   
   while(!que.empty())
   {
       Node *temp = que.front();
       que.pop();
       
       if(temp -> left)
       que.push(temp -> left);
       
       if(temp -> right)
       que.push(temp -> right);
       
       cout<<"Deleting Node with Value "< data<<"\n";
       delete temp;
   }
   
   root = NULL;
}

int main()
{
    /* Creating a Binary trees and inserting some nodes in it */
    Node *root = NULL;
    
    root = new Node(1);
    root -> left = new Node(2);
    root -> right = new Node(3);
    root -> left -> left = new Node(4);
    root -> left -> right = new Node(5);
    root -> right -> left = new Node(6);
    root -> right -> right = new Node (7);
    root -> left -> right -> left = new Node(8);
    root -> right -> left -> right = new Node(9);
    
    /* Calling function to delete binary tree */
    deleteTree(root);
}

OUTPUT:

Deleting Node with Value 1
Deleting Node with Value 2
Deleting Node with Value 3
Deleting Node with Value 4
Deleting Node with Value 5
Deleting Node with Value 6
Deleting Node with Value 7
Deleting Node with Value 8
Deleting Node with Value 9

Related Posts:

The post Delete Binary Tree appeared first on Helpmestudybro.

Check if two trees are mirror tree of each other

admin — Fri, 22 Jan 2021 20:37:42 +0000

“Check if two trees are mirror tree of each other” is a basic problem based on tree data structure. Here, we are given two binary tree and our task is to write a program to check whether given two binary trees are mirror tree of each other.

Check if two trees are mirror tree of each other

Two trees are known as mirror tree of each other if they satisfy following conditions:

Both must be empty or non-empty tree.
Root Node data must be same.
Left subtree of first tree must be equal to right subtree of second tree.
Right subtree of first tree must be equal to left subtree of second tree.

C++ Program to check if two trees are mirror tree of each other is as follows:

/* C++ Program to check if two trees are mirror tree of each other */
#include
using namespace std;

typedef struct Node
{
    int data;
    struct Node *left;
    struct Node *right;
    Node(int ele)
    {
        data = ele;
        left = NULL;
        right = NULL;
    }
} Node;

/* Function to check if two trees are mirror tree of each other */
bool checkMirror(Node *root1, Node *root2)
{
    /* Base Case1: If both Trees are Empty */
    if(root1 == NULL && root2 == NULL)
    return true;
    
    /* Base Case2: If one tree is empty and other not */
    if(root1 == NULL || root2 == NULL)
    return false;
    
    /*
        If Both are Non-Empty, Recursively compare data of left subtree of 
        first tree with right subtree of second tree and vice-versa
    */
    return root1 -> data == root2 -> data &&
           checkMirror(root1 -> left, root2 -> right) &&
           checkMirror(root1 -> right,root2 -> left);
}

int main()
{
    /* Creating a Binary trees and inserting some nodes in it */
    Node *root1 = NULL;
    Node *root2 = NULL;
    
    /* Inserting some Nodes in first tree */
    root1 = new Node(1);
    root1 -> left = new Node(2);
    root1 -> right = new Node(3);
    root1 -> left -> left = new Node(4);
    root1 -> left -> right = new Node(5);
    root1 -> right -> left = new Node(6);
    root1 -> right -> right = new Node (7);
    root1 -> left -> right -> left = new Node(8);
    root1 -> right -> left -> right = new Node(9);
    
    /* Inserting some Nodes in second tree */
    root2 = new Node(1);
    root2 -> right = new Node(2);
    root2 -> left = new Node(3);
    root2 -> right -> right = new Node(4);
    root2 -> right -> left = new Node(5);
    root2 -> left -> right = new Node(6);
    root2 -> left -> left = new Node (7);
    root2 -> right -> left -> right = new Node(8);
    root2 -> left -> right -> left = new Node(9);
    
    /* Calling function to check if two trees are mirror tree of each other*/
    if(checkMirror(root1,root2) == true)
    {
        cout<<"Both Trees are Mirror Tree of Each Other!!";
    }
    else
    {
        cout<<"Both Trees are not Mirror Tree of Each Other!!";
    }
    
}

OUTPUT:

Both Trees are Mirror Tree of Each Other!!

Related Posts:

The post Check if two trees are mirror tree of each other appeared first on Helpmestudybro.

Top View of Binary Tree

admin — Fri, 22 Jan 2021 20:19:04 +0000

“Top View of Binary Tree” is one of the foremost algorithmic problem asked in technical interviews of product-based companies. Here, we are given a binary tree and our task is to write a program to print the top view of given binary tree.

Top View of Binary Tree is referred to those nodes of binary tree which can be seen from top of the tree.

Top View of Binary Tree

The idea here is similar to vertical order traversal of binary tree. We will perform the vertical order traversal and print only those nodes which are first nodes of vertical order line.

The steps required to print top view of Binary Tree are as follows:

Create a map which store the vertical order line number and corresponding first/top node value.
Create a queue which can accommodate both node and corresponding horizontal distance with root node.
Insert the root node into queue and 0 as horizontal distance.
Perform following steps until queue is node empty.
- Pop front Element of queue.
- Check if popped horizontal distance already present in the map or not. If not, insert the popped node value into map.
- If left child exists of popped node, insert into queue with horizontal distance as current HD-1.
- If right child exists of popped node, insert into queue with horizontal distance as current HD+1.
Print the map data which contains top view.

C++ Program to print top view of binary tree is as follows:

/* C++ Program to print top view of Binary Tree */
#include
using namespace std;

typedef struct Node
{
    int data;
    struct Node *left;
    struct Node *right;
    Node(int ele)
    {
        data = ele;
        left = NULL;
        right = NULL;
    }
} Node;

/* Function to print top view of Binary Tree */
void topView(Node *root)
{
    /* Base Case */
    if(root == NULL)
    return;
    
    /*
        Create a map which store top view nodes
        key: vertical order line
        pair: Top node of vertical order line
    */
    map mp;
    
    /*
        Create queue which store both node and corresponding HD
    */
    queue> que;
    int hd = 0;
    
    que.push(make_pair(root,hd));
    
    while(!que.empty())
    {
        /* Pop front Node */
        pair temp = que.front();
        que.pop();
        Node *temp_node = temp.first;
        int currHD = temp.second;
        
        /* 
            If vertical order line is not present in map, 
            then insert the node value in the map, as it will the 
            first node of the verical order line
        */
        if(mp.find(currHD) == mp.end())
        {
            mp[currHD] = temp_node -> data;
        }
        
        if(temp_node -> left)
        que.push(make_pair(temp_node -> left, currHD - 1));
        
        if(temp_node -> right)
        que.push(make_pair(temp_node -> right, currHD + 1));
    }
    
    /* Print map, which contain top view nodes */
    map :: iterator itr;
    for(itr = mp.begin(); itr != mp.end(); ++itr)
    {
        cout << itr -> second << " ";
    }
}

int main()
{
    /* Creating a Binary tree and inserting some nodes in it */
    Node *root = NULL;
    
    root = new Node(1);
    root -> left = new Node(2);
    root -> right = new Node(3);
    root -> left -> left = new Node(4);
    root -> left -> right = new Node(5);
    root -> right -> left = new Node(6);
    root -> right -> right = new Node (7);
    root -> left -> right -> left = new Node(8);
    root -> right -> left -> right = new Node(9);
    
    /* Calling function to print top view of binary tree*/
    cout<<"The top View of Given Binary Tree is:\n";
    topView(root);
}

OUTPUT:

The top View of Given Binary Tree is:
4 2 1 3 7

Related Posts:

The post Top View of Binary Tree appeared first on Helpmestudybro.

Bottom View of Binary Tree

admin — Fri, 22 Jan 2021 20:07:22 +0000

“Bottom View of Binary Tree” is one of the foremost algorithmic problem asked in technical interviews of product-based companies. Here, we are given a binary tree and our task is to write a program to print the bottom view of given binary tree.

Bottom View of Binary Tree is referred to those nodes of binary tree which can be seen from bottom of the tree.

We need to print the node values from left to right.

If there are multiple bottom-most nodes for a same horizontal distance from root node, then we need to print the one which occurs later in our traversal algorithm.

Bottom View of Binary Tree

The idea here is similar to vertical order traversal of binary tree. We will perform the vertical order traversal and print only those nodes which occurs in last of vertical order line.

The steps required to print bottom view of binary tree are as follows:

Create a map which store the vertical order line number and corresponding bottom node value.
Create a queue which can accommodate both node and corresponding horizontal distance with root node.
Insert the root node into queue and 0 as horizontal distance.
Perform following steps until queue is node empty.
- Pop front Element of queue.
- Assign the popped node value to map, according to horizontal distance. Every time we encounter a node with already existing horizontal distance node value present in the map, we will replace it.
- If left child exists of popped node, insert into queue with horizontal distance as current HD-1.
- If right child exists of popped node, insert into queue with horizontal distance as current HD+1.
Print the map data which contains bottom view.

C++ Program to print bottom view of binary tree are as follows:

/* C++ Program to print Bottom View of Binary Tree */
#include
using namespace std;

typedef struct Node
{
    int data;
    struct Node *left;
    struct Node *right;
    Node(int ele)
    {
        data = ele;
        left = NULL;
        right = NULL;
    }
} Node;

/* Function to print bottom view of Binary Tree */
void bottomView(Node *root)
{
    /* Base Case */
    if(root == NULL)
    return;
    
    /*
        Create a map which store bottom view nodes
        key: vertical order line
        Value: Top node of vertical order line
    */
    map mp;
    
    /*
        Create queue which store both node and corresponding HD
    */
    queue> que;
    int hd = 0;
    
    que.push(make_pair(root,hd));
    
    while(!que.empty())
    {
        /* Pop front Node */
        pair temp = que.front();
        que.pop();
        Node *temp_node = temp.first;
        int currHD = temp.second;
        
        /* 
            Assign the popped node value to map having same HD.
            Every time we find a node having same horizontal distance,
            we replace its value in the map
        */
        mp[currHD] = temp_node -> data;
        
        if(temp_node -> left)
        que.push(make_pair(temp_node -> left, currHD - 1));
        
        if(temp_node -> right)
        que.push(make_pair(temp_node -> right, currHD + 1));
    }
    
    /* Print map, which contain bottom view nodes */
    map :: iterator itr;
    for(itr = mp.begin(); itr != mp.end(); ++itr)
    {
        cout << itr -> second << " ";
    }
}

int main()
{
    /* Creating a Binary tree and inserting some nodes in it */
    Node *root = NULL;
    
    root = new Node(1);
    root -> left = new Node(2);
    root -> right = new Node(3);
    root -> left -> left = new Node(4);
    root -> left -> right = new Node(5);
    root -> right -> left = new Node(6);
    root -> right -> right = new Node (7);
    root -> left -> right -> left = new Node(8);
    root -> right -> left -> right = new Node(9);
    
    /* Calling function to print bottom view of binary tree*/
    cout<<"The bottom View of Given Binary Tree is:\n";
    bottomView(root);
}

OUTPUT:

The bottom View of Given Binary Tree is:
4 8 6 9 7

Related Posts:

The post Bottom View of Binary Tree appeared first on Helpmestudybro.

Vertical Traversal of Binary Tree

admin — Fri, 22 Jan 2021 19:53:35 +0000

“Vertical Traversal of Binary Tree” is one of the foremost algorithmic problem based on tree data structure asked in technical interview. Here, we are given a binary tree and our task is to traverse the given binary tree vertically.

Vertical Traversal of Binary Tree

For vertical order traversal, we need to calculate Horizontal Distance (HD) for each node of given binary tree. Horizontal Distance in case of Binary Tree is defined as distance of node from root node. Horizontal Distance of Root Node is always considered as 0, then right child node will have HD as +1 and left child node will have HD as -1. If two nodes have same horizontal distance, then they are considered to be on same vertical Line.

There can be varied ways to traverse the binary tree vertically. Here, in this post we are going to discuss two methods to implement the Vertical Binary Tree Traversal.

Preorder Traversal with Hashing
Level Order Traversal with Hashing

METHOD 1: Preorder Traversal with Hashing

Here, we can recursively calculate Horizontal distance of each node and insert the node into HashMap accordingly.

The steps required to implement Vertical Traversal of Binary Tree are as follows:

Create a HashMap to store Vertical Order and node value.
For root, initialize HD = 0.
Recursively perform following steps:
- Check and return from Base Case.
- Store the current node into map according to its HD.
- Recursively Call the function for left subtree by passing current HD – 1.
- Recursively Call the function for right subtree by passing current HD + 1.
Print the Vertical traversal stored in HashMap.

C++ Program to implement Vertical Traversal of Binary Tree is as follows:

/* C++ Program to implement vertical traversal of Binary Tree */
#include
using namespace std;

typedef struct Node
{
    int data;
    struct Node *left;
    struct Node *right;
    Node(int ele)
    {
        data = ele;
        left = NULL;
        right = NULL;
    }
} Node;

/* Function to insert node values in hashmap according to horizontal distances */
void verticalTraversalRecurr(Node *root, int HD, map> &mp)
{
    /* Base Case */
    if(root == NULL)
    return;
    
    /* Store Current Node into Map */
    mp[HD].push_back(root -> data);
    
    /* Recursively Call for left subtree by updating HD-1 */
    verticalTraversalRecurr(root -> left, HD-1, mp);
    
    /* Recursively Call for right subtree by updating HD+1 */
    verticalTraversalRecurr(root -> right, HD+1, mp);
}

/* Function to Implement Vertical Traversal of Binary Tree */
void verticalTraversal(Node *root)
{
    /* Base Case */
    if(root == NULL)
    return;
    
    map> mp;
    int hd = 0;
    verticalTraversalRecurr(root, hd, mp);
    
    /* Print the Vertical Traversal, stored in HashMap */
    map > :: iterator itr;
    for(itr = mp.begin(); itr != mp.end(); ++itr)
    {
        for(int i = 0; i < itr -> second.size(); i++)
        cout << itr->second[i] << " ";
        
        cout< left = new Node(2);
    root -> right = new Node(3);
    root -> left -> left = new Node(4);
    root -> left -> right = new Node(5);
    root -> right -> left = new Node(6);
    root -> right -> right = new Node (7);
    root -> left -> right -> left = new Node(8);
    root -> right -> left -> right = new Node(9);
    
    /* Calling function to perform vertical traversal*/
    cout<<"The Veritcal Traversal of the Given Binary Tree is:\n";
    verticalTraversal(root);
}

OUTPUT:

The Veritcal Traversal of the Given Binary Tree is:
4 
2 8 
1 5 6 
3 9 
7

METHOD 2: Level Order Traversal using Hashing

Here, we are going modify the queue used in Level order traversal to store both node and corresponding horizontal distance of each node. Also, we need to create a map which store the vertical order line of tree.

The steps required to implement Vertical Traversal of Binary Tree are as follows:

Create a map which store the vertical order and corresponding nodes.
Create a queue which can store node and corresponding HD and push root node with corresponding distance as 0.
Perform following steps until queue is not empty:
- Pop the element from queue and store it in the map according to vertical order.
- If the popped node has left child, push it into queue and pass HD as current (HD-1).
- If popped node has right child push it into queue and pass HD as current (HD+1).
Display the data of map which stores the vertical order traversal of given binary tree.

C++ Program to implement Vertical Traversal of Binary Tree is as follows:

/* C++ Program to implement vertical traversal of Binary Tree */
#include
using namespace std;

typedef struct Node
{
    int data;
    struct Node *left;
    struct Node *right;
    Node(int ele)
    {
        data = ele;
        left = NULL;
        right = NULL;
    }
} Node;

/* Function to Implement Vertical Traversal of Binary Tree */
void verticalTraversal(Node *root)
{
    /* Base Case */
    if(root == NULL)
    return;
    
    /* 
        Create a map which store the vertical order traversal,
        "int" refers to store the vertical line number
        "vector" refers to the chained node values lying on verical line
    */
    map > mp;
    int hd = 0;
    
    /*
        Create Queue and every element of queue will store 
        node and corresponding Horizontal Distance
    */
    queue> que;
    que.push(make_pair(root,hd));
    
    while(!que.empty())
    {
        /* Pop Front Element from queue */
        pair temp = que.front();
        que.pop();
        
        hd = temp.second;
        Node *temp_node = temp.first;
        
        /* Push the Node into map according to vertical order line */
        mp[hd].push_back(temp_node -> data);
        
        if(temp_node -> left)
        que.push(make_pair(temp_node -> left, hd - 1));
        
         if(temp_node -> right)
        que.push(make_pair(temp_node -> right, hd + 1));
    }
    
    /* Print map ehich holds vertical order traversal */
    map> :: iterator itr;
    for(itr = mp.begin(); itr != mp.end(); ++itr)
    {
        for(int i = 0; i < itr->second.size(); i++)
        {
            cout << itr -> second[i] << " ";
        }
        cout< left = new Node(2);
    root -> right = new Node(3);
    root -> left -> left = new Node(4);
    root -> left -> right = new Node(5);
    root -> right -> left = new Node(6);
    root -> right -> right = new Node (7);
    root -> left -> right -> left = new Node(8);
    root -> right -> left -> right = new Node(9);
    
    /* Calling function to perform vertical traversal*/
    cout<<"The Veritcal Traversal of the Given Binary Tree is:\n";
    verticalTraversal(root);
}

OUTPUT:

The Veritcal Traversal of the Given Binary Tree is:
4 
2 8 
1 5 6 
3 9 
7

Related Posts:

The post Vertical Traversal of Binary Tree appeared first on Helpmestudybro.