# Convert a Binary Tree into its Mirror Tree

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

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

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 `

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: This program is similar to traversal of tree space and time complexities will be same as Tree traversal (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 `

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.

My Personal Notes arrow_drop_up

Article Tags :

49

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.