How to Convert Binary Tree to Mirror Tree (Inverted)

Do you want to know how to convert Binary Tree To Mirror Tree? In this article, you will learn to convert a Binary Tree to Its Mirror or Inverted view.

What is Mirror Tree?

When you are having a given binary tree, then the mirror of that tree would be that all the left children of the root node should be right children in the mirror tree, and similarly, all the right children of the root node should be left children of the mirror tree.

In the below code we will see how you can implement the code to mirror the binary tree. We are going to use the recursive method to swap the left and right child using postorder traversal or preorder traversal.

C++ Implementation of Mirror Tree

Below code is the implementation of Conversion of Mirror or Inverted Binary Tree in C++.

#include<bits/stdc++.h>
using namespace std;

    /**
 * Definition for a binary tree node.
 */ struct TreeNode {
         int val;
         TreeNode *left;
         TreeNode *right;
         TreeNode() : val(0), left(nullptr), right(nullptr) {}
         TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
         TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 };

class MirrorTree {
public:

    //Function to Convert the Binary Tree to Inverted or Mirror Tree
    // And Return the Root Node.
    TreeNode* invertTree(TreeNode* root) {
        //If Root is NULL then return NULL
        if(!root) return NULL;

        TreeNode* leftNode = invertTree(root->left);
        TreeNode* rightNode = invertTree(root->right);

        root->left = rightNode;
        root->right = leftNode;

        return root;
    }

    //Function to Print the Inorder Traversal of Tree
    void printInorder(TreeNode* root){
        if(!root) return;

        printInorder(root->left);
        cout<<root->val<<" ";
        printInorder(root->right);

    }
};

int main(){

    //Initialization

    MirrorTree objToCallFunc;

    //Creating Example Tree Structure to Mirror it
    // Or Create A Inverted Tree out of it.

    TreeNode* root = new TreeNode(4);
    root->left = new TreeNode(2);
    root->right = new TreeNode(6);
    root->left->left = new TreeNode(1);
    root->left->right = new TreeNode(3);
    root->right->left = new TreeNode(5);
    root->right->right = new TreeNode(7);

    //Print the Original Tree.
    cout<<"Origin Binary Tree: ";
    objToCallFunc.printInorder(root);
    cout<<endl;

    //creating the MirrorTree Object to call the function
    // To create the inverted Image.

    TreeNode* invertedTree = objToCallFunc.invertTree(root);

    //Print the Inorder Traversal of inverted Tree.
    cout<<"Mirror Binary Tree: ";
    objToCallFunc.printInorder(invertedTree);

    return 0;
}

Output:

Origin Binary Tree: 1 2 3 4 5 6 7 
Mirror Binary Tree: 7 6 5 4 3 2 1 

As you can see in the above output, in the first Inorder traversal^[1] the number is printed in ascending order, and when we flipped the tree all the values are printed in descending order.

Python Implementation of Mirror or Inverted Tree

Below is the Python implementation for the above problem.

# Definition for a binary tree node.
from os import sep


class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


def invertTree(root: TreeNode):
    if root == None:
        return None

    leftNode = invertTree(root.left)
    rightNode = invertTree(root.right)

    root.right = leftNode
    root.left = rightNode

    return root

def inorderTraversal(root: TreeNode):
    if root==None: 
        return
        
    inorderTraversal(root.left)
    print(root.val, end=" ")
    inorderTraversal(root.right)


#Creating the Tree
root = TreeNode(4)
root.left = TreeNode(2)
root.right = TreeNode(6)
root.left.left = TreeNode(1)
root.left.right = TreeNode(3)
root.right.left = TreeNode(5)
root.right.right = TreeNode(7)

#calling inorder Traversal to Print the Tree
inorderTraversal(root)

newRoot = invertTree(root)

print("\nNew Mirror Tree")
inorderTraversal(newRoot)

print(newRoot)

Output:

1 2 3 4 5 6 7  
New Mirror Tree
7 6 5 4 3 2 1

That is all for how to convert Binary Tree to Mirror Tree or Inverted Tree. Let me know if you have any questions in the comment section. Also, let me know if you want the code in a different language as well.

And please follow us on Facebook and Twitter. Let us know the questions and answer you want to cover in this blog.

Further Read:

1. Kadane’s Algorithm: Maximum Sum Subarray Problem