Kth ancestor of a node in binary tree | Set 2

Given a binary tree in which nodes are numbered from 1 to n. Given a node and a positive integer K. We have to print the Kth ancestor of the given node in the binary tree. If there does not exist any such ancestor then print -1.
For example in the below given binary tree, the 2nd ancestor of 5 is 1. 3rd ancestor of node 5 will be -1. 

We have discussed a BFS-based solution for this problem in our previous article. If you observe that solution carefully, you will see that the basic approach was to first find the node and then backtrack to the kth parent. The same thing can be done using recursive DFS without using an extra array. 

The idea of using DFS is to first find the given node in the tree and then backtrack k times to reach the kth ancestor. Once we have reached the kth parent, we will simply print the node and return NULL. 

Below is the implementation of the above idea: 

C++

/* C++ program to calculate Kth ancestor of given node */
#include <bits/stdc++.h>
using namespace std;

// A Binary Tree Node
struct Node
{
    int data;
    struct Node *left, *right;
};

// temporary node to keep track of Node returned
// from previous recursive call during backtrack
Node* temp = NULL;

// recursive function to calculate Kth ancestor
Node* kthAncestorDFS(Node *root, int node , int &k)
{
    // Base case
    if (!root)
        return NULL;

    if (root->data == node||
       (temp =  kthAncestorDFS(root->left,node,k)) ||
       (temp =  kthAncestorDFS(root->right,node,k)))
    {
        if (k > 0)
            k--;

        else if (k == 0)
        {
            // print the kth ancestor
            cout<<"Kth ancestor is: "<<root->data;

            // return NULL to stop further backtracking
            return NULL;
        }

        // return current node to previous call
        return root;
    }
}

// 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;
}

// Driver program to test above functions
int main()
{
    // Let us create binary tree shown in above diagram
    Node *root = newNode(1);
    root->left = newNode(2);
    root->right = newNode(3);
    root->left->left = newNode(4);
    root->left->right = newNode(5);

    int k = 2;
    int node = 5;

    // print kth ancestor of given node
    Node* parent = kthAncestorDFS(root,node,k);

    // check if parent is not NULL, it means
    // there is no Kth ancestor of the node
    if (parent)
        cout << "-1";

    return 0;
}

Java

// Java program to calculate Kth ancestor of given node
public class Solution
{

// A Binary Tree Node
static class Node
{
    int data;
    Node left, right;
};

// temporary node to keep track of Node returned
// from previous recursive call during backtrack
static Node temp = null;
static int k;

// recursive function to calculate Kth ancestor
static Node kthAncestorDFS(Node root, int node )
{
    // Base case
    if (root == null)
        return null;

    if (root.data == node||
    (temp = kthAncestorDFS(root.left,node)) != null ||
    (temp = kthAncestorDFS(root.right,node)) != null)
    {
        if (k > 0)
            k--;

        else if (k == 0)
        {
            // print the kth ancestor
            System.out.print("Kth ancestor is: "+root.data);

            // return null to stop further backtracking
            return null;
        }

        // return current node to previous call
        return root;
    }
    return null;
}

// Utility function to create a new tree node
static Node newNode(int data)
{
    Node temp = new Node();
    temp.data = data;
    temp.left = temp.right = null;
    return temp;
}

// Driver code
public static void main(String args[])
{
    // Let us create binary tree shown in above diagram
    Node root = newNode(1);
    root.left = newNode(2);
    root.right = newNode(3);
    root.left.left = newNode(4);
    root.left.right = newNode(5);

    k = 2;
    int node = 5;

    // print kth ancestor of given node
    Node parent = kthAncestorDFS(root,node);

    // check if parent is not null, it means
    // there is no Kth ancestor of the node
    if (parent != null)
        System.out.println("-1");
}
}

// This code is contributed by Arnab Kundu

Python3

# Python program to calculate the
# ancestor of given node

# A Binary Tree Node
class newNode:
    # Constructor to create a new node
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None


# recursive function to calculate Kth ancestor
def kthAncestorDFS(root, node, k):

    # Base case
    if (not root):
        return None

    if (root.data == node or
       (kthAncestorDFS(root.left, node, k)) or
       (kthAncestorDFS(root.right, node, k))):

        if (k[0] > 0):
            k[0] -= 1

        elif (k[0] == 0):

            # print the kth ancestor
            print("Kth ancestor is:", root.data)

            # return None to stop further backtracking
            return None

        # return current node to previous call
        return root

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

k = [2]
node = 5

# print kth ancestor of given node
parent = kthAncestorDFS(root,node,k)

# check if parent is not None, it means
# there is no Kth ancestor of the node
if (parent):
  print("-1")

# This code is contributed YASH AGARWAL(yashagarwal2852002)

C#

// C# program to calculate Kth ancestor of given node
using System;

class GFG
{

// A Binary Tree Node
public class Node
{
    public int data;
    public Node left, right;
};

// temporary node to keep track of Node returned
// from previous recursive call during backtrack
static Node temp = null;
static int k;

// recursive function to calculate Kth ancestor
static Node kthAncestorDFS(Node root, int node )
{
    // Base case
    if (root == null)
        return null;

    if (root.data == node||
    (temp = kthAncestorDFS(root.left,node)) != null ||
    (temp = kthAncestorDFS(root.right,node)) != null)
    {
        if (k > 0)
            k--;

        else if (k == 0)
        {
            // print the kth ancestor
            Console.Write("Kth ancestor is: "+root.data);

            // return null to stop further backtracking
            return null;
        }

        // return current node to previous call
        return root;
    }
    return null;
}

// Utility function to create a new tree node
static Node newNode(int data)
{
    Node temp = new Node();
    temp.data = data;
    temp.left = temp.right = null;
    return temp;
}

// Driver code
public static void Main(String []args)
{
    // Let us create binary tree shown in above diagram
    Node root = newNode(1);
    root.left = newNode(2);
    root.right = newNode(3);
    root.left.left = newNode(4);
    root.left.right = newNode(5);

    k = 2;
    int node = 5;

    // print kth ancestor of given node
    Node parent = kthAncestorDFS(root,node);

    // check if parent is not null, it means
    // there is no Kth ancestor of the node
    if (parent != null)
        Console.WriteLine("-1");
}
}

// This code is contributed by 29AjayKumar

Javascript

<script>

// JavaScript program to calculate Kth
// ancestor of given node

// A Binary Tree Node
class Node
{
    constructor()
    {
        this.data = 0;
        this.left = null;
        this.right = null;
    }
};

// temporary node to keep track of Node returned
// from previous recursive call during backtrack
var temp = null;
var k = 0;

// recursive function to calculate Kth ancestor
function kthAncestorDFS(root, node )
{
    // Base case
    if (root == null)
        return null;

    if (root.data == node||
    (temp = kthAncestorDFS(root.left,node)) != null ||
    (temp = kthAncestorDFS(root.right,node)) != null)
    {
        if (k > 0)
            k--;

        else if (k == 0)
        {
            // print the kth ancestor
            document.write("Kth ancestor is: "+root.data);

            // return null to stop further backtracking
            return null;
        }

        // return current node to previous call
        return root;
    }
    return null;
}

// Utility function to create a new tree node
function newNode(data)
{
    var temp = new Node();
    temp.data = data;
    temp.left = temp.right = null;
    return temp;
}

// Driver code
// Let us create binary tree shown in above diagram
var root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.left.right = newNode(5);
k = 2;
var node = 5;
// print kth ancestor of given node
var parent = kthAncestorDFS(root,node);

// check if parent is not null, it means
// there is no Kth ancestor of the node
if (parent != null)
    document.write("-1");



</script>

Output

Kth ancestor is: 1

Time Complexity: O(n), where n is the number of nodes in the binary tree. 

Auxiliary Space: O(h) where h is the height of binary tree due to recursion call.

 This article is contributed by Harsh Agarwal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.