Skip to content
Related Articles

Related Articles

Improve Article
Find n-th node in Preorder traversal of a Binary Tree
  • Difficulty Level : Basic
  • Last Updated : 23 Jun, 2021

Given a Binary tree and a number N, write a program to find the N-th node in the Preorder traversal of the given Binary tree.
Prerequisite: Tree Traversal
Examples: 
 

Input:      N = 4
              11
            /   \
           21    31
         /   \
        41     51
Output: 51
Explanation: Preorder Traversal of given Binary Tree is 11 21 41 51 31, 
so 4th node will be 51.

Input:      N = 5
             25
           /    \
          20    30
        /    \ /   \
      18    22 24   32
Output: 30

 

The idea to solve this problem is to do preorder traversal of the given binary tree and keep track of the count of nodes visited while traversing the tree and print the current node when the count becomes equal to N. 
 

C++




// C++ program to find n-th node of
// Preorder Traversal of Binary Tree
#include <bits/stdc++.h>
using namespace std;
 
// Tree node
struct Node {
    int data;
    Node *left, *right;
};
 
// function to create new node
struct Node* createNode(int item)
{
    Node* temp = new Node;
    temp->data = item;
    temp->left = NULL;
    temp->right = NULL;
 
    return temp;
}
 
// function to find the N-th node in the preorder
// traversal of a given binary tree
void NthPreordernode(struct Node* root, int N)
{
    static int flag = 0;
 
    if (root == NULL)
        return;
 
    if (flag <= N) {
        flag++;
 
        // prints the n-th node of preorder traversal
        if (flag == N)
            cout << root->data;
 
        // left recursion
        NthPreordernode(root->left, N);
 
        // right recursion
        NthPreordernode(root->right, N);
    }
}
 
// Driver code
int main()
{
    // construction of binary tree
    struct Node* root = createNode(25);
    root->left = createNode(20);
    root->right = createNode(30);
    root->left->left = createNode(18);
    root->left->right = createNode(22);
    root->right->left = createNode(24);
    root->right->right = createNode(32);
 
    // nth node
    int N = 6;
 
    // prints n-th found found
    NthPreordernode(root, N);
 
    return 0;
}

Java




// Java program to find n-th node of
// Preorder Traversal of Binary Tree
class GFG
{
 
// Tree node
static class Node
{
    int data;
    Node left, right;
};
 
// function to create new node
static Node createNode(int item)
{
    Node temp = new Node();
    temp.data = item;
    temp.left = null;
    temp.right = null;
 
    return temp;
}
static int flag = 0;
 
// function to find the N-th node in the preorder
// traversal of a given binary tree
static void NthPreordernode(Node root, int N)
{
     
 
    if (root == null)
        return;
 
    if (flag <= N)
    {
        flag++;
 
        // prints the n-th node of preorder traversal
        if (flag == N)
            System.out.print( root.data);
 
        // left recursion
        NthPreordernode(root.left, N);
 
        // right recursion
        NthPreordernode(root.right, N);
    }
}
 
// Driver code
public static void main(String args[])
{
    // construction of binary tree
    Node root = createNode(25);
    root.left = createNode(20);
    root.right = createNode(30);
    root.left.left = createNode(18);
    root.left.right = createNode(22);
    root.right.left = createNode(24);
    root.right.right = createNode(32);
 
    // nth node
    int N = 6;
 
    // prints n-th found found
    NthPreordernode(root, N);
}
}
 
// This code contributed by Arnab Kundu

Python3




# Python program to find n-th node of
# Preorder Traversal of Binary Tree
 
class createNode():
 
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None
         
         
# function to find the N-th node in the preorder
# traversal of a given binary tree
flag = [0]
def NthPreordernode(root, N):
    if (root == None):
        return
 
    if (flag[0] <= N):
        flag[0] += 1
 
        # prints the n-th node of preorder traversal
        if (flag[0] == N):
            print(root.data)
 
        # left recursion
        NthPreordernode(root.left, N)
 
        # right recursion
        NthPreordernode(root.right, N)
         
# Driver code
if __name__ == '__main__':
     
    # construction of binary tree
    root = createNode(25)
    root.left = createNode(20)
    root.right = createNode(30)
    root.left.left = createNode(18)
    root.left.right = createNode(22)
    root.right.left = createNode(24)
    root.right.right = createNode(32)
 
    # nth node
    N = 6
 
    # prints n-th found found
    NthPreordernode(root, N)
 
# This code is contributed by SHUBHAMSINGH10

C#




// C# program to find n-th node of
// Preorder Traversal of Binary Tree
using System;
     
class GFG
{
 
// Tree node
public class Node
{
    public int data;
    public Node left, right;
};
 
// function to create new node
static Node createNode(int item)
{
    Node temp = new Node();
    temp.data = item;
    temp.left = null;
    temp.right = null;
 
    return temp;
}
static int flag = 0;
 
// function to find the N-th node in the preorder
// traversal of a given binary tree
static void NthPreordernode(Node root, int N)
{
     
 
    if (root == null)
        return;
 
    if (flag <= N)
    {
        flag++;
 
        // prints the n-th node of preorder traversal
        if (flag == N)
            Console.Write( root.data);
 
        // left recursion
        NthPreordernode(root.left, N);
 
        // right recursion
        NthPreordernode(root.right, N);
    }
}
 
// Driver code
public static void Main(String []args)
{
    // construction of binary tree
    Node root = createNode(25);
    root.left = createNode(20);
    root.right = createNode(30);
    root.left.left = createNode(18);
    root.left.right = createNode(22);
    root.right.left = createNode(24);
    root.right.right = createNode(32);
 
    // nth node
    int N = 6;
 
    // prints n-th found found
    NthPreordernode(root, N);
}
}
 
// This code is contributed by Rajput-Ji

Javascript




<script>
// Javascript program to find n-th node of
// Preorder Traversal of Binary Tree
 
// Tree node
class Node
{
    constructor()
    {
        this.data = 0;
        this.left = null;
        this.right = null;
    }
};
 
// function to create new node
function createNode(item)
{
    var temp = new Node();
    temp.data = item;
    temp.left = null;
    temp.right = null;
 
    return temp;
}
 
var flag = 0;
 
// function to find the N-th node in the preorder
// traversal of a given binary tree
function NthPreordernode(root, N)
{
     
 
    if (root == null)
        return;
 
    if (flag <= N)
    {
        flag++;
 
        // prints the n-th node of preorder traversal
        if (flag == N)
            document.write( root.data);
 
        // left recursion
        NthPreordernode(root.left, N);
 
        // right recursion
        NthPreordernode(root.right, N);
    }
}
 
// Driver code
// construction of binary tree
var root = createNode(25);
root.left = createNode(20);
root.right = createNode(30);
root.left.left = createNode(18);
root.left.right = createNode(22);
root.right.left = createNode(24);
root.right.right = createNode(32);
 
// nth node
var N = 6;
 
// prints n-th found found
NthPreordernode(root, N);
 
// This code is contributed by famously.
</script>
Output: 
24

 

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

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 industry experts, please refer DSA Live Classes 




My Personal Notes arrow_drop_up
Recommended Articles
Page :