Related Articles

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

• Difficulty Level : Easy
• Last Updated : 05 Aug, 2021

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

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++

 `// 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

 `// 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

 `# 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#

 `// 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`

## Javascript

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

Time Complexity: O(N)
Auxiliary Space: O(N)

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