Find the parent of a node in the given binary tree

Last Updated : 22 Oct, 2024

Given a Binary Tree and a node, the task is to find the parent of the given node in the tree. Return -1 if the given node is the root node.
Note: In a binary tree, a parent node of a given node is the node that is directly connected above the given node.

Examples:

Input: target = 3

Output: 1
Explanation: Parent of the target node i.e. 3 is 1
Input: target = 1

Output: -1
Explanation: Parent of the target node i.e. 3 is -1, since it is the root node.

Approach:

The idea is to write a recursive function that takes the current node and its parent as the arguments (root node is passed with -1 as its parent). If the current node is equal to the required node then print its parent and return, else call the function recursively for its children and the current node as the parent.

Below is the implementation of the above approach:

C++

// C++ implementation to find the parent of 
// a target node in a binary tree
#include <iostream>
using namespace std;

class Node {
public:
    int data;
    Node* left;
    Node* right;

    Node(int x) {
        data = x;
        left = nullptr;
        right = nullptr;
    }
};

// Recursive function to find the parent 
// of the target node
int findParent(Node* root, int target, int parent) {
    if (root == nullptr) {
        return -1;
    }
    
    // If current node is the target, 
    // return its parent
    if (root->data == target) {
        return parent;
    }
    
    // Recursively search in left subtree
    int leftSearch = findParent(root->left,
                                target, root->data);
  
    if (leftSearch != -1) {
        return leftSearch;
    }
    
    // Recursively search in right subtree
    return findParent(root->right, target, root->data);
}

int main() {
  
    // Representation of the given tree
    //         1
    //        / \
    //       2   3
    //      / \
    //     4   5
    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);

    int target = 3; 
 
    int parent = findParent(root, target, -1);

    cout << parent << endl;

    return 0;
}

Java

// Java implementation to find the parent of 
// a target node in a binary tree
import java.util.*;

class Node {
    int data;
    Node left;
    Node right;

    Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

// Recursive function to find the parent 
// of the target node
class GfG {

    static int findParent(Node root, 
                          int target, int parent) {
      
        if (root == null) {
            return -1;
        }

        // If current node is the target, 
        // return its parent
        if (root.data == target) {
            return parent;
        }

        // Recursively search in left subtree
        int leftSearch = findParent(root.left,
                                    target, root.data);
  
        if (leftSearch != -1) {
            return leftSearch;
        }

        // Recursively search in right subtree
        return findParent(root.right, target, root.data);
    }

    public static void main(String[] args) {

        // Representation of the given tree
        //         1
        //        / \
        //       2   3
        //      / \
        //     4   5
        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);

        int target = 3; 

        int parent = findParent(root, target, -1);
        System.out.println(parent);
    }
}

Python

# Python implementation to find the parent of 
# a target node in a binary tree

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

# Recursive function to find the parent 
# of the target node
def find_parent(root, target, parent):
    if root is None:
        return -1
    
    # If current node is the target, 
    # return its parent
    if root.data == target:
        return parent
    
    # Recursively search in left subtree
    left_search = find_parent(root.left,
                              target, root.data)
    
    if left_search != -1:
        return left_search
    
    # Recursively search in right subtree
    return find_parent(root.right, target, root.data)

if __name__ == "__main__":
    
    # Representation of the given tree
    #         1
    #        / \
    #       2   3
    #      / \
    #     4   5
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.left = Node(4)
    root.left.right = Node(5)

    target = 3
    parent = find_parent(root, target, -1)

    print(parent)

// C# implementation to find the parent of 
// a target node in a binary tree
using System;

class Node {
    public int data;
    public Node left;
    public Node right;

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

// Recursive function to find the parent 
// of the target node
class GfG {

    static int FindParent(Node root, 
                          int target, int parent) {
      
        if (root == null) {
            return -1;
        }

        // If current node is the target, 
        // return its parent
        if (root.data == target) {
            return parent;
        }

        // Recursively search in left subtree
        int leftSearch = FindParent(root.left,
                                    target, root.data);

        if (leftSearch != -1) {
            return leftSearch;
        }

        // Recursively search in right subtree
        return FindParent(root.right, target, root.data);
    }

    static void Main(string[] args) {

        // Representation of the given tree
        //         1
        //        / \
        //       2   3
        //      / \
        //     4   5
        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);

        int target = 3;

        int parent = FindParent(root, target, -1);

        Console.WriteLine(parent);
    }
}

JavaScript

// JavaScript implementation to find the parent of 
// a target node in a binary tree
class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

// Recursive function to find the parent 
// of the target node
function findParent(root, target, parent) {
    if (root === null) {
        return -1;
    }

    // If current node is the target, 
    // return its parent
    if (root.data === target) {
        return parent;
    }

    // Recursively search in left subtree
    let leftSearch = findParent(root.left,
                                target, root.data);

    if (leftSearch !== -1) {
        return leftSearch;
    }

    // Recursively search in right subtree
    return findParent(root.right, target, root.data);
}

// Representation of the given tree
//         1
//        / \
//       2   3
//      / \
//     4   5
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);

let target = 3;

let parent = findParent(root, target, -1);
console.log(parent);

Output

Time complexity: O(n), where n is the number of nodes, as each node is visited once.
Auxiliary Space: O(h), where h is the height of the tree, due to the recursive call stack.

Find the parent of a node in the given binary tree

soumibardhan10

Improve

Article Tags :

Practice Tags :

Find the parent of a node in the given binary tree

Similar Reads

Thank You!

What kind of Experience do you want to share?