Related Articles

# Convert a Binary Tree into its Mirror Tree

• Difficulty Level : Easy
• Last Updated : 10 Jul, 2021

Mirror of a Tree: Mirror of a Binary Tree T is another Binary Tree M(T) with left and right children of all non-leaf nodes interchanged. Trees in the above figure are mirror of each other

Method 1 (Recursive)

Algorithm – Mirror(tree):

```(1)  Call Mirror for left-subtree    i.e., Mirror(left-subtree)
(2)  Call Mirror for right-subtree  i.e., Mirror(right-subtree)
(3)  Swap left and right subtrees.
temp = left-subtree
left-subtree = right-subtree
right-subtree = temp```

## C++

 `// C++ program to convert a binary tree``// to its mirror``#include``using` `namespace` `std;` `/* 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);``}`  `/* Change a tree so that the roles of the left and``    ``right pointers are swapped at every node.` `So the tree...``    ``4``    ``/ \``    ``2 5``    ``/ \``1 3` `is changed to...``    ``4``    ``/ \``    ``5 2``        ``/ \``    ``3 1``*/``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 print``Inorder traversal.*/``void` `inOrder(``struct` `Node* node)``{``    ``if` `(node == NULL)``        ``return``;``    ` `    ``inOrder(node->left);``    ``cout << node->data << ``" "``;``    ``inOrder(node->right);``}`  `// Driver Code``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 */``    ``cout << ``"Inorder traversal of the constructed"``         ``<< ``" tree is"` `<< endl;``    ``inOrder(root);``    ` `    ``/* Convert tree to its mirror */``    ``mirror(root);``    ` `    ``/* Print inorder traversal of the mirror tree */``    ``cout << ``"\nInorder traversal of the mirror tree"``         ``<< ``" is \n"``;``    ``inOrder(root);``    ` `    ``return` `0;``}` `// This code is contributed by Akanksha Rai`

## C

 `// C program to convert a binary tree``// to its mirror``#include``#include` `/* 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);``}`  `/* Change a tree so that the roles of the  left and``    ``right pointers are swapped at every node.` ` ``So the tree...``       ``4``      ``/ \``     ``2   5``    ``/ \``   ``1   3` ` ``is changed to...``       ``4``      ``/ \``     ``5   2``        ``/ \``       ``3   1``*/``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 print Inorder traversal.*/``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``(``"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``(``"\nInorder traversal of the mirror tree"``         ``" is \n"``); ``  ``inOrder(root);``  ` `  ``return` `0; ``}`

## Java

 `// Java program to convert binary tree into its mirror` `/* Class containing left and right child of current``   ``node and key value*/``class` `Node``{``    ``int` `data;``    ``Node left, right;` `    ``public` `Node(``int` `item)``    ``{``        ``data = item;``        ``left = right = ``null``;``    ``}``}` `class` `BinaryTree``{``    ``Node root;` `    ``void` `mirror()``    ``{``        ``root = mirror(root);``    ``}` `    ``Node mirror(Node node)``    ``{``        ``if` `(node == ``null``)``            ``return` `node;` `        ``/* do the subtrees */``        ``Node left = mirror(node.left);``        ``Node right = mirror(node.right);` `        ``/* swap the left and right pointers */``        ``node.left = right;``        ``node.right = left;` `        ``return` `node;``    ``}` `    ``void` `inOrder()``    ``{``        ``inOrder(root);``    ``}` `    ``/* Helper function to test mirror(). Given a binary``       ``search tree, print out its data elements in``       ``increasing sorted order.*/``    ``void` `inOrder(Node node)``    ``{``        ``if` `(node == ``null``)``            ``return``;` `        ``inOrder(node.left);``        ``System.out.print(node.data + ``" "``);` `        ``inOrder(node.right);``    ``}` `    ``/* testing for example nodes */``    ``public` `static` `void` `main(String args[])``    ``{``        ``/* creating a binary tree and entering the nodes */``        ``BinaryTree tree = ``new` `BinaryTree();``        ``tree.root = ``new` `Node(``1``);``        ``tree.root.left = ``new` `Node(``2``);``        ``tree.root.right = ``new` `Node(``3``);``        ``tree.root.left.left = ``new` `Node(``4``);``        ``tree.root.left.right = ``new` `Node(``5``);` `        ``/* print inorder traversal of the input tree */``        ``System.out.println(``"Inorder traversal of input tree is :"``);``        ``tree.inOrder();``        ``System.out.println(``""``);` `        ``/* convert tree to its mirror */``        ``tree.mirror();` `        ``/* print inorder traversal of the minor tree */``        ``System.out.println(``"Inorder traversal of binary tree is : "``);``        ``tree.inOrder();` `    ``}``}`

## Python3

 `# Python3 program to convert a binary``# tree to its mirror` `# Utility function to create a new``# tree node``class` `newNode:``    ``def` `__init__(``self``,data):``        ``self``.data ``=` `data``        ``self``.left ``=` `self``.right ``=` `None` `""" Change a tree so that the roles of the``    ``left and right pointers are swapped at``    ``every node.` `So the tree...``        ``4``        ``/ \``    ``2 5``    ``/ \``    ``1 3` `is changed to...``    ``4``    ``/ \``    ``5 2``    ``/ \``    ``3 1``"""``def` `mirror(node):` `    ``if` `(node ``=``=` `None``):``        ``return``    ``else``:` `        ``temp ``=` `node``        ` `        ``""" 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 print Inorder traversal."""``def` `inOrder(node) :` `    ``if` `(node ``=``=` `None``):``        ``return``        ` `    ``inOrder(node.left)``    ``print``(node.data, end ``=` `" "``)``    ``inOrder(node.right)` `# Driver code``if` `__name__ ``=``=``"__main__"``:` `    ``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 """``    ``print``(``"Inorder traversal of the"``,``               ``"constructed tree is"``)``    ``inOrder(root)``    ` `    ``""" Convert tree to its mirror """``    ``mirror(root)` `    ``""" Print inorder traversal of``        ``the mirror tree """``    ``print``(``"\nInorder traversal of"``,``              ``"the mirror treeis "``)``    ``inOrder(root)` `# This code is contributed by``# Shubham Singh(SHUBHAMSINGH10)`

## C#

 `// C# program to convert binary``// tree into its mirror``using` `System;` `// Class containing left and right``// child of current node and key value``public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node left, right;` `    ``public` `Node(``int` `item)``    ``{``        ``data = item;``        ``left = right = ``null``;``    ``}``}` `class` `GFG``{``public` `Node root;` `public` `virtual` `void` `mirror()``{``    ``root = mirror(root);``}` `public` `virtual` `Node mirror(Node node)``{``    ``if` `(node == ``null``)``    ``{``        ``return` `node;``    ``}` `    ``/* do the subtrees */``    ``Node left = mirror(node.left);``    ``Node right = mirror(node.right);` `    ``/* swap the left and right pointers */``    ``node.left = right;``    ``node.right = left;` `    ``return` `node;``}` `public` `virtual` `void` `inOrder()``{``    ``inOrder(root);``}` `/* Helper function to test mirror().``Given a binary search tree, print out its``data elements in increasing sorted order.*/``public` `virtual` `void` `inOrder(Node node)``{``    ``if` `(node == ``null``)``    ``{``        ``return``;``    ``}` `    ``inOrder(node.left);``    ``Console.Write(node.data + ``" "``);` `    ``inOrder(node.right);``}` `/* testing for example nodes */``public` `static` `void` `Main(``string``[] args)``{``    ``/* creating a binary tree and``    ``entering the nodes */``    ``GFG tree = ``new` `GFG();``    ``tree.root = ``new` `Node(1);``    ``tree.root.left = ``new` `Node(2);``    ``tree.root.right = ``new` `Node(3);``    ``tree.root.left.left = ``new` `Node(4);``    ``tree.root.left.right = ``new` `Node(5);` `    ``/* print inorder traversal of the input tree */``    ``Console.WriteLine(``"Inorder traversal "` `+``                      ``"of input tree is :"``);``    ``tree.inOrder();``    ``Console.WriteLine(``""``);` `    ``/* convert tree to its mirror */``    ``tree.mirror();` `    ``/* print inorder traversal of the minor tree */``    ``Console.WriteLine(``"Inorder traversal "` `+``                    ``"of binary tree is : "``);``    ``tree.inOrder();``}``}` `// This code is contributed by Shrikant13`

## Javascript

 ``

Output:

```Inorder traversal of the constructed tree is
4 2 5 1 3
Inorder traversal of the mirror tree is
3 1 5 2 4 ```

Time & Space Complexities: Worst-case Time complexity is O(n) and for space complexity, If we don’t consider the size of the recursive stack for function calls then O(1) otherwise O(h) where h is the height of the tree.  This program is similar to traversal of tree space and time complexities will be the same as Tree traversal more for information Please see our Tree Traversal post for details.

Method 2 (Iterative)

The idea is to do queue based level order traversal. While doing traversal, swap left and right children of every node.

## C++

 `// Iterative CPP program to convert a Binary``// Tree to its mirror``#include``using` `namespace` `std;` `/* 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 = ``new` `Node;``    ``node->data = data;``    ``node->left = node->right = NULL;``    ``return``(node);``}` `/* Change a tree so that the roles of the  left and``    ``right pointers are swapped at every node.`` ``So the tree...``       ``4``      ``/ \``     ``2   5``    ``/ \``   ``1   3` ` ``is changed to...``       ``4``      ``/ \``     ``5   2``        ``/ \``       ``3   1``*/``void` `mirror(Node* root)``{``    ``if` `(root == NULL)``        ``return``;` `    ``queue q;``    ``q.push(root);` `    ``// Do BFS. While doing BFS, keep swapping``    ``// left and right children``    ``while` `(!q.empty())``    ``{``        ``// pop top node from queue``        ``Node* curr = q.front();``        ``q.pop();` `        ``// swap left child with right child``        ``swap(curr->left, curr->right);` `        ``// push left and right children``        ``if` `(curr->left)``            ``q.push(curr->left);``        ``if` `(curr->right)``            ``q.push(curr->right);``    ``}``}`  `/* Helper function to print Inorder traversal.*/``void` `inOrder(``struct` `Node* node)``{``    ``if` `(node == NULL)``        ``return``;``    ``inOrder(node->left);``    ``cout << 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 */``    ``cout << ``"\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 */``    ``cout << ``"\n Inorder traversal of the "``           ``"mirror tree is \n"``;``    ``inOrder(root);` `    ``return` `0;``}`

## Java

 `// Iterative Java program to convert a Binary``// Tree to its mirror``import` `java.util.*;` `class` `GFG``{``    ` `/* A binary tree node has data, pointer to``left child and a pointer to right child */``static` `class` `Node``{``    ``int` `data;``    ``Node left;``    ``Node right;``};` `/* Helper function that allocates a new node``with the given data and null left and right``pointers. */``static` `Node newNode(``int` `data)` `{``    ``Node node = ``new` `Node();``    ``node.data = data;``    ``node.left = node.right = ``null``;``    ``return``(node);``}` `/* Change a tree so that the roles of the left and``    ``right pointers are swapped at every node.``So the tree...``    ``4``    ``/ \``    ``2 5``    ``/ \``1 3` `is changed to...``    ``4``    ``/ \``    ``5 2``        ``/ \``    ``3 1``*/``static` `void` `mirror(Node root)``{``    ``if` `(root == ``null``)``        ``return``;` `    ``Queue q = ``new` `LinkedList<>();``    ``q.add(root);` `    ``// Do BFS. While doing BFS, keep swapping``    ``// left and right children``    ``while` `(q.size() > ``0``)``    ``{``        ``// pop top node from queue``        ``Node curr = q.peek();``        ``q.remove();` `        ``// swap left child with right child``        ``Node temp = curr.left;``        ``curr.left = curr.right;``        ``curr.right = temp;;` `        ``// push left and right children``        ``if` `(curr.left != ``null``)``            ``q.add(curr.left);``        ``if` `(curr.right != ``null``)``            ``q.add(curr.right);``    ``}``}`  `/* Helper function to print Inorder traversal.*/``static` `void` `inOrder( Node node)``{``    ``if` `(node == ``null``)``        ``return``;``    ``inOrder(node.left);``    ``System.out.print( node.data + ``" "``);``    ``inOrder(node.right);``}`  `/* Driver code */``public` `static` `void` `main(String args[])``{``    ``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 */``    ``System.out.print( ``"\n Inorder traversal of the"``            ``+``" coned tree is \n"``);``    ``inOrder(root);` `    ``/* Convert tree to its mirror */``    ``mirror(root);` `    ``/* Print inorder traversal of the mirror tree */``    ``System.out.print( ``"\n Inorder traversal of the "``+``        ``"mirror tree is \n"``);``    ``inOrder(root);``}``}` `// This code is contributed by Arnab Kundu`

## Python3

 `# Python3 program to convert a Binary``# Tree to its mirror` `# A binary tree node has data, pointer to``# left child and a pointer to right child``# Helper function that allocates a new node``# with the given data and None left and``# right pointers``class` `newNode:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `''' Change a tree so that the roles of the left``    ``and right pointers are swapped at every node.``    ``So the tree...``        ``4``        ``/ \``        ``2 5``        ``/ \``    ``1 3``    ` `    ``is changed to...``        ``4``        ``/ \``        ``5 2``            ``/ \``        ``3 1``    ``'''``    ` `def` `mirror( root):` `    ``if` `(root ``=``=` `None``):``        ``return` `    ``q ``=` `[]``    ``q.append(root)` `    ``# Do BFS. While doing BFS, keep swapping``    ``# left and right children``    ``while` `(``len``(q)):` `        ``# pop top node from queue``        ``curr ``=` `q[``0``]``        ``q.pop(``0``)` `        ``# swap left child with right child``        ``curr.left, curr.right ``=` `curr.right, curr.left` `        ``# append left and right children``        ``if` `(curr.left):``            ``q.append(curr.left)``        ``if` `(curr.right):``            ``q.append(curr.right)` `""" Helper function to print Inorder traversal."""``def` `inOrder( node):``    ``if` `(node ``=``=` `None``):``        ``return``    ``inOrder(node.left)``    ``print``(node.data, end ``=` `" "``)``    ``inOrder(node.right)` `# Driver code``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 """``print``(``"Inorder traversal of the constructed tree is"``)``inOrder(root)` `""" Convert tree to its mirror """``mirror(root)` `""" Print inorder traversal of the mirror tree """``print``(``"\nInorder traversal of the mirror tree is"``)``inOrder(root)` `# This code is contributed by SHUBHAMSINGH10`

## C#

 `// C# Iterative Java program to convert a Binary``// Tree to its mirror``using` `System.Collections.Generic;``using` `System;``    ` `class` `GFG``{``    ` `/* A binary tree node has data, pointer to``left child and a pointer to right child */``public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node left;``    ``public` `Node right;``};` `/* Helper function that allocates a new node``with the given data and null left and right``pointers. */``static` `Node newNode(``int` `data)` `{``    ``Node node = ``new` `Node();``    ``node.data = data;``    ``node.left = node.right = ``null``;``    ``return``(node);``}` `/* Change a tree so that the roles of the left and``    ``right pointers are swapped at every node.``So the tree...``    ``4``    ``/ \``    ``2 5``    ``/ \``1 3` `is changed to...``    ``4``    ``/ \``    ``5 2``        ``/ \``    ``3 1``*/``static` `void` `mirror(Node root)``{``    ``if` `(root == ``null``)``        ``return``;` `    ``Queue q = ``new` `Queue();``    ``q.Enqueue(root);` `    ``// Do BFS. While doing BFS, keep swapping``    ``// left and right children``    ``while` `(q.Count > 0)``    ``{``        ``// pop top node from queue``        ``Node curr = q.Peek();``        ``q.Dequeue();` `        ``// swap left child with right child``        ``Node temp = curr.left;``        ``curr.left = curr.right;``        ``curr.right = temp;;` `        ``// push left and right children``        ``if` `(curr.left != ``null``)``            ``q.Enqueue(curr.left);``        ``if` `(curr.right != ``null``)``            ``q.Enqueue(curr.right);``    ``}``}`  `/* Helper function to print Inorder traversal.*/``static` `void` `inOrder( Node node)``{``    ``if` `(node == ``null``)``        ``return``;``    ``inOrder(node.left);``    ``Console.Write( node.data + ``" "``);``    ``inOrder(node.right);``}`  `/* Driver code */``public` `static` `void` `Main(String []args)``{``    ``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 */``    ``Console.Write( ``"\n Inorder traversal of the"``            ``+``" coned tree is \n"``);``    ``inOrder(root);` `    ``/* Convert tree to its mirror */``    ``mirror(root);` `    ``/* Print inorder traversal of the mirror tree */``    ``Console.Write( ``"\n Inorder traversal of the "``+``        ``"mirror tree is \n"``);``    ``inOrder(root);``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

``` Inorder traversal of the constructed tree is
4 2 5 1 3
Inorder traversal of the mirror tree is
3 1 5 2 4 ```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up