Print Head node of every node in Binary Tree

Given the root of the Binary Tree. Print the parent node of each node in the given Binary Tree. 

Examples : 

Input: Binary Tree = {1, 2, 3, 4, 5, NULL, NULL, NULL, 6}

Example 1

Output : 

• The Head Node of 6 is 4  
• The Head Nodeof 5 is 2
• The Head Node of 4 is 2
• The Head Node of 3 is 1 
• The Head Node of 2 is 1  

Explanation: Clearly By Observing Image we are finding parent node for each and every Node. 

Input:  Binary Tree ={1, 2, 3, 4, 5, 6, 7, 8, 9, 10}  
Output: 

• The Head Node of 10 is 5
• The Head Nodeof 9 is 4
• The Head Node of 8 is 4
• The Head Node of 7  is 3
• The Head Node of 6  is 3
• The Head Node of 5 is 2
• The Head Nodeof 4 is 2
• The Head Node of 3 is 1
• The Head Node of 2 is 1 

Approach: This can be solved with the following idea:

Using  map data structure, and using child node as a key and it’s parent node as a value for that particular value. Traversing in Level order in binary tree using queue.

Steps involved in the implementation of code:

•   Create an unordered map function with parameters of type Node* as ParentNodes.
• Push root into the queue q.
•   while the queue is not empty iterate throughout the queue and assign root to its left and right as :
  • ParentNodes[root->left] = root
  • ParentNodes[root->right] = root
• Parallelly push the left and right nodes of the root into the queue for further iteration. 

Below is the implementation of the above approach: 

C++

// C++ program to print head of each node in tree
#include <bits/stdc++.h>
using namespace std;

// A binary tree node has data, a pointer
// to the left child and a pointer
// to the right child
struct Node {
    int data;
    struct Node *left, *right;
};

// Utility function to create a
// new tree node
Node* newNode(int data)
{

    Node* temp = new Node;
    temp->data = data;
    temp->left = temp->right = NULL;

    return temp;
}

// Function to print parent Node
void Print_Head_Nodes(
    Node* root, unordered_map<Node*, Node*>& ParentNodes)
{

    // Using Queue structure
    queue<Node*> q;

    q.push(root);

    while (!q.empty()) {

        Node* k = q.front();
        q.pop();

        // Check if left node is present
        if (k->left) {
            ParentNodes[k->left] = k;
            q.push(k->left);
        }

        // Check if right node is present
        if (k->right) {
            ParentNodes[k->right] = k;
            q.push(k->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);
    root->left->left->right = newNode(6);

    // Map data Structure
    unordered_map<Node*, Node*> ParentNodes;

    // Function call
    Print_Head_Nodes(root, ParentNodes);

    // Printing parent of each node
    for (auto i : ParentNodes) {
        cout << "The Head Node of " << i.first->data
             << " is " << i.second->data << endl;
    }
    return 0;
}

Java

// Java program to print head of each node in tree

import java.io.*;
import java.util.*;

// A binary tree node has data, a pointer to the left child
// and a pointer to the right child
class Node {
    int data;
    Node left, right;

    // Constructor
    Node(int data)
    {
        this.data = data;
        left = right = null;
    }
}

class GFG {

    // Function to print parent Node
    static void
    Print_Head_Nodes(Node root,
                     HashMap<Node, Node> ParentNodes)
    {

        // Using Queue structure
        Queue<Node> q = new LinkedList<>();
        q.add(root);

        while (!q.isEmpty()) {

            Node k = q.peek();
            q.remove();

            // Check if left node is present
            if (k.left != null) {
                ParentNodes.put(k.left, k);
                q.add(k.left);
            }

            // Check if right node is present
            if (k.right != null) {
                ParentNodes.put(k.right, k);
                q.add(k.right);
            }
        }
    }

    public static void main(String[] args)
    {
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.left.left.right = new Node(6);

        // Map data Structure
        HashMap<Node, Node> ParentNodes = new HashMap<>();

        // Function call
        Print_Head_Nodes(root, ParentNodes);

        // Printing parent of each node
        for (Map.Entry<Node, Node> i :
             ParentNodes.entrySet()) {
            System.out.println("The Head Node of "
                               + i.getKey().data + " is "
                               + i.getValue().data);
        }
    }
}

// This code is contributed by karthik.

Python3

# Python program to print head of each node in tree

# A binary tree node has data, a pointer
# to the left child and a pointer
# to the right child


class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

# Utility function to create a
# new tree node


def newNode(data):

    temp = Node(data)
    return temp

# Function to print parent Node


def Print_Head_Nodes(root, ParentNodes):

    # Using Queue structure
    q = []

    q.append(root)

    while q:

        k = q.pop(0)

        # Check if left node is present
        if k.left:
            ParentNodes[k.left] = k
            q.append(k.left)

        # Check if right node is present
        if k.right:
            ParentNodes[k.right] = k
            q.append(k.right)


# Driver code
root = newNode(1)
root.left = newNode(2)
root.right = newNode(3)
root.left.left = newNode(4)
root.left.right = newNode(5)
root.left.left.right = newNode(6)

# Map data Structure
ParentNodes = {}

# Function call
Print_Head_Nodes(root, ParentNodes)

# Printing parent of each node
for i in ParentNodes:
    print("The Head Node of ", i.data,
          " is ", ParentNodes[i].data)

# This code is contributed by prasad264

C#

// C# program to print head of each node in tree
using System;
using System.Collections.Generic;

// A binary tree node has data, a pointer
// to the left child and a pointer
// to the right child
public class Node {
    public int data;
    public Node left, right;

    public Node(int data)
    {
        this.data = data;
        left = right = null;
    }
}

public class GFG {
    // Function to print parent Node
    public static void
    Print_Head_Nodes(Node root,
                     Dictionary<Node, Node> ParentNodes)
    {
        // Using Queue structure
        Queue<Node> q = new Queue<Node>();

        q.Enqueue(root);

        while (q.Count > 0) {
            Node k = q.Dequeue();

            // Check if left node is present
            if (k.left != null) {
                ParentNodes[k.left] = k;
                q.Enqueue(k.left);
            }

            // Check if right node is present
            if (k.right != null) {
                ParentNodes[k.right] = k;
                q.Enqueue(k.right);
            }
        }
    }

    // Driver code
    public static void Main()
    {
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.left.left.right = new Node(6);

        // Dictionary data Structure
        Dictionary<Node, Node> ParentNodes
            = new Dictionary<Node, Node>();

        // Function call
        Print_Head_Nodes(root, ParentNodes);

        // Printing parent of each node in opposite order
        for (int i = ParentNodes.Count - 1; i >= 0; i--) {
            KeyValuePair<Node, Node> pair
                = new List<KeyValuePair<Node, Node> >(
                    ParentNodes)[i];
            Console.WriteLine("The Head Node of {0} is {1}",
                              pair.Key.data,
                              pair.Value.data);
        }
    }
}

// This code is contributed by Susobhan Akhuli

Javascript

// JavaScript program to print head of each node in tree

// A binary tree node has data, a pointer
// to the left child and a pointer
// to the right child
class Node {
  constructor(data) {
    this.data = data;
    this.left = null;
    this.right = null;
  }
}

// Function to print parent Node
function Print_Head_Nodes(root, ParentNodes) {

  // Using Queue structure
  let q = [];

  q.push(root);

  while (q.length > 0) {

    let k = q.shift();

    // Check if left node is present
    if (k.left) {
      ParentNodes.set(k.left, k);
      q.push(k.left);
    }

    // Check if right node is present
    if (k.right) {
      ParentNodes.set(k.right, k);
      q.push(k.right);
    }
  }
}

// Driver code
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.left.left.right = new Node(6);

// Map data Structure
let ParentNodes = new Map();

// Function call
Print_Head_Nodes(root, ParentNodes);

// Store the entries of the ParentNodes map into an array
let entries = Array.from(ParentNodes.entries());

// Loop through the array in reverse order to print the entries
for (let i = entries.length - 1; i >= 0; i--) {
  let [key, value] = entries[i];
  console.log(`The Head Node of ${key.data} is ${value.data}`);
}

// This code is contributed by Susobhan Akhuli.

Output

The Head Node of 6 is 4
The Head Node of 5 is 2
The Head Node of 4 is 2
The Head Node of 3 is 1
The Head Node of 2 is 1

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