# Sum of the mirror image nodes of a complete binary tree in an inorder way

Given a complete binary tree, the task is to find the sum of mirror image nodes in an inorder way i.e. find the inorder traversal of the left sub-tree and for every node traversed, add the value of its mirror node to the current node’s value.

Examples:

Input:

Output:
20
51
19
10
Inorder traversal of the left sub-tree of the given tree is 4 23 11 5.
4 + 16 = 20
23 + 28 = 51
11 + 8 = 19
5 + 5 = 10

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: We will use 2 pointers to maintain 2 nodes which are the mirror image of each other. So let’s take root1 and root2 are 2 mirror image nodes. Now left child of root1 and right child of root2 will be the mirror image of each other. We will pass these two nodes (root1->left and root2->right) for next recursive call. Since we have to traverse in an inorder manner so once left sub-tree is traversed then we print the current root data and then we traverse the right sub-tree. Similarly for the right sub-tree so right child of root1 and left child of root2 will be the mirror image of each other. We will pass these two nodes (root1->right and root2->left) for next recursive call.

Below is the implementation of the above approach

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` `typedef` `struct` `node { ` ` `  `    ``// struct to store data and links to ` `    ``// its left and right child ` `    ``int` `data; ` `    ``struct` `node* l; ` `    ``struct` `node* r; ` `    ``node(``int` `d) ` `    ``{ ` ` `  `        ``// Initialize data for the current node ` `        ``// with the passed value as d ` `        ``data = d; ` ` `  `        ``// Initialize left child to NULL ` `        ``l = NULL; ` ` `  `        ``// Initialize right child to NULL ` `        ``r = NULL; ` `    ``} ` `} Node; ` ` `  `// Function to print the required inorder traversal ` `void` `printInorder(Node* rootL, Node* rootR) ` `{ ` `    ``// We are using 2 pointers for the nodes ` `    ``// which are mirror image of each other ` `    ``// If both child are NULL return ` `    ``if` `(rootL->l == NULL && rootR->r == NULL) ` `        ``return``; ` ` `  `    ``// Since inorder traversal is required ` `    ``// First left, then root and then right ` `    ``printInorder(rootL->l, rootR->r); ` `    ``cout << rootL->l->data + rootR->r->data << endl; ` `    ``printInorder(rootL->r, rootR->l); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``Node* root = ``new` `Node(5); ` `    ``root->l = ``new` `Node(23); ` `    ``root->r = ``new` `Node(28); ` `    ``root->l->l = ``new` `Node(4); ` `    ``root->l->r = ``new` `Node(11); ` `    ``root->r->l = ``new` `Node(8); ` `    ``root->r->r = ``new` `Node(16); ` ` `  `    ``printInorder(root, root); ` ` `  `    ``// Since root is mirror image of itself ` `    ``if` `(root) ` `        ``cout << root->data * 2 << endl; ` ` `  `    ``return` `0; ` `} `

 `// Java implementation of the approach ` `import` `java.util.*; ` ` `  `class` `GFG ` `{  ` `    ``static` `class` `Node  ` `    ``{ ` ` `  `        ``// struct to store data and links to ` `        ``// its left and right child ` `        ``int` `data; ` `        ``Node l; ` `        ``Node r; ` `        ``Node(``int` `d) ` `        ``{ ` `     `  `            ``// Initialize data for the current Node ` `            ``// with the passed value as d ` `            ``data = d; ` `     `  `            ``// Initialize left child to null ` `            ``l = ``null``; ` `     `  `            ``// Initialize right child to null ` `            ``r = ``null``; ` `        ``} ` `    ``}  ` ` `  `    ``// Function to print the required inorder traversal ` `    ``static` `void` `printInorder(Node rootL, Node rootR) ` `    ``{ ` `        ``// We are using 2 pointers for the Nodes ` `        ``// which are mirror image of each other ` `        ``// If both child are null return ` `        ``if` `(rootL.l == ``null` `&& rootR.r == ``null``) ` `            ``return``; ` `     `  `        ``// Since inorder traversal is required ` `        ``// First left, then root and then right ` `        ``printInorder(rootL.l, rootR.r); ` `        ``System.out.println(rootL.l.data + rootR.r.data ); ` `        ``printInorder(rootL.r, rootR.l); ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``Node root = ``new` `Node(``5``); ` `        ``root.l = ``new` `Node(``23``); ` `        ``root.r = ``new` `Node(``28``); ` `        ``root.l.l = ``new` `Node(``4``); ` `        ``root.l.r = ``new` `Node(``11``); ` `        ``root.r.l = ``new` `Node(``8``); ` `        ``root.r.r = ``new` `Node(``16``); ` `     `  `        ``printInorder(root, root); ` `     `  `        ``// Since root is mirror image of itself ` `        ``if` `(root != ``null``) ` `            ``System.out.println(root.data * ``2` `); ` `     `  `    ``} ` `} ` ` `  `// This code is contributed by Arnab Kundu `

 `# Python3 implementation of the approach  ` ` `  `class` `Node: ` `     `  `    ``def` `__init__(``self``, d): ` `        ``self``.data ``=` `d ` `        ``self``.l ``=` `None` `        ``self``.r ``=` `None` ` `  `# Function to print the required inorder traversal  ` `def` `printInorder(rootL, rootR):  ` `  `  `    ``# We are using 2 pointers for the nodes  ` `    ``# which are mirror image of each other  ` `    ``# If both child are None return  ` `    ``if` `rootL.l ``=``=` `None` `and` `rootR.r ``=``=` `None``:  ` `        ``return`  ` `  `    ``# Since inorder traversal is required  ` `    ``# First left, then root and then right  ` `    ``printInorder(rootL.l, rootR.r)  ` `    ``print``(rootL.l.data ``+` `rootR.r.data)  ` `    ``printInorder(rootL.r, rootR.l)  ` `  `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"``:  ` `  `  `    ``root ``=` `Node(``5``)  ` `    ``root.l ``=` `Node(``23``)  ` `    ``root.r ``=` `Node(``28``)  ` `    ``root.l.l ``=` `Node(``4``)  ` `    ``root.l.r ``=` `Node(``11``)  ` `    ``root.r.l ``=` `Node(``8``)  ` `    ``root.r.r ``=` `Node(``16``)  ` ` `  `    ``printInorder(root, root)  ` ` `  `    ``# Since root is mirror image of itself  ` `    ``if` `root: ` `        ``print``(root.data ``*` `2``)  ` ` `  `# This code is contributed by Rituraj Jain `

 `// C# implementation of the approach ` `using` `System; ` ` `  `class` `GFG ` `{  ` `    ``public` `class` `Node  ` `    ``{ ` ` `  `        ``// struct to store data and links to ` `        ``// its left and right child ` `        ``public` `int` `data; ` `        ``public` `Node l; ` `        ``public` `Node r; ` `        ``public` `Node(``int` `d) ` `        ``{ ` `     `  `            ``// Initialize data for the current Node ` `            ``// with the passed value as d ` `            ``data = d; ` `     `  `            ``// Initialize left child to null ` `            ``l = ``null``; ` `     `  `            ``// Initialize right child to null ` `            ``r = ``null``; ` `        ``} ` `    ``}  ` ` `  `    ``// Function to print the required inorder traversal ` `    ``static` `void` `printInorder(Node rootL, Node rootR) ` `    ``{ ` `        ``// We are using 2 pointers for the Nodes ` `        ``// which are mirror image of each other ` `        ``// If both child are null return ` `        ``if` `(rootL.l == ``null` `&& rootR.r == ``null``) ` `            ``return``; ` `     `  `        ``// Since inorder traversal is required ` `        ``// First left, then root and then right ` `        ``printInorder(rootL.l, rootR.r); ` `        ``Console.WriteLine(rootL.l.data + rootR.r.data ); ` `        ``printInorder(rootL.r, rootR.l); ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String []args) ` `    ``{ ` `        ``Node root = ``new` `Node(5); ` `        ``root.l = ``new` `Node(23); ` `        ``root.r = ``new` `Node(28); ` `        ``root.l.l = ``new` `Node(4); ` `        ``root.l.r = ``new` `Node(11); ` `        ``root.r.l = ``new` `Node(8); ` `        ``root.r.r = ``new` `Node(16); ` `     `  `        ``printInorder(root, root); ` `     `  `        ``// Since root is mirror image of itself ` `        ``if` `(root != ``null``) ` `            ``Console.WriteLine(root.data * 2 ); ` `     `  `    ``} ` `} ` ` `  `// This code is contributed by Arnab Kundu `

Output:
```20
51
19
10
```

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.

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :