Skip to content
Related Articles

Related Articles

Improve Article

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

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

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. 
Adding the mirror nodes, 
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 <iostream>
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




<script>
 
// Javascript implementation of the approach
class Node
{
    constructor(d)
    {
        this.l = null;
        this.r = null;
        this.data = d;
    }
}
 
// Function to print the required inorder traversal
function printInorder(rootL, 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);
    document.write(rootL.l.data +
                   rootR.r.data + "</br>");
    printInorder(rootL.r, rootR.l);
}
 
// Driver code
let 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)
    document.write(root.data * 2 );
 
// This code is contributed by suresh07
 
</script>
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
Recommended Articles
Page :