Open in App
Not now

# Find n-th node in Postorder traversal of a Binary Tree

• Difficulty Level : Easy
• Last Updated : 27 Jan, 2023

Given a Binary tree and a number N, write a program to find the N-th node in the Postorder traversal of the given Binary tree.

Prerequisite: Tree Traversal

Examples:

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

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

The idea to solve this problem is to do postorder 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.

Below is the implementation of the above approach:

## C++

 `// C++ program to find n-th node of` `// Postorder Traversal of Binary Tree` `#include ` `using` `namespace` `std;`   `// node of tree` `struct` `Node {` `    ``int` `data;` `    ``Node *left, *right;` `};`   `// function to create a 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 postorder` `// traversal of a given binary tree` `void` `NthPostordernode(``struct` `Node* root, ``int` `N)` `{` `    ``static` `int` `flag = 0;`   `    ``if` `(root == NULL)` `        ``return``;`   `    ``if` `(flag <= N) {`   `        ``// left recursion` `        ``NthPostordernode(root->left, N);`   `        ``// right recursion` `        ``NthPostordernode(root->right, N);`   `        ``flag++;`   `        ``// prints the n-th node of preorder traversal` `        ``if` `(flag == N)` `            ``cout << root->data;` `    ``}` `}`   `// driver code` `int` `main()` `{` `    ``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);`   `    ``int` `N = 6;`   `    ``// prints n-th node found` `    ``NthPostordernode(root, N);`   `    ``return` `0;` `}`

## Java

 `// Java program to find n-th node of ` `// Postorder Traversal of Binary Tree ` `public` `class` `NthNodePostOrder {`   `    ``static` `int` `flag = ``0``; `   `    ``// function to find the N-th node in the postorder ` `    ``// traversal of a given binary tree ` `    ``public` `static` `void` `NthPostordernode(Node root, ``int` `N) ` `    ``{ ` `  `  `        ``if` `(root == ``null``) ` `            ``return``; ` `  `  `        ``if` `(flag <= N) ` `        ``{   ` `            ``// left recursion ` `            ``NthPostordernode(root.left, N); ` `            ``// right recursion ` `            ``NthPostordernode(root.right, N); ` `            ``flag++; ` `            ``// prints the n-th node of preorder traversal ` `            ``if` `(flag == N) ` `                ``System.out.print(root.data);` `        ``} ` `    ``} `     `    ``public` `static` `void` `main(String args[]) {` `        ``Node root = ``new` `Node(``25``); ` `        ``root.left = ``new` `Node(``20``); ` `        ``root.right = ``new` `Node(``30``); ` `        ``root.left.left = ``new` `Node(``18``); ` `        ``root.left.right = ``new` `Node(``22``); ` `        ``root.right.left = ``new` `Node(``24``); ` `        ``root.right.right = ``new` `Node(``32``); ` `  `  `        ``int` `N = ``6``; ` `  `  `        ``// prints n-th node found ` `        ``NthPostordernode(root, N);` `    ``}` `}`   `/* A binary tree node structure */` `class` `Node ` `{ ` `    ``int` `data; ` `    ``Node left, right; ` `    ``Node(``int` `data)` `    ``{` `        ``this``.data=data;` `    ``}` `};` `// This code is contributed by Gaurav Tiwari`

## Python3

 `"""Python3 program to find n-th node of ` `Postorder Traversal of Binary Tree"""`   `# A Binary Tree Node ` `# Utility function to create a new tree node ` `class` `createNode: `   `    ``# Constructor to create a newNode ` `    ``def` `__init__(``self``, data): ` `        ``self``.data``=` `data ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# function to find the N-th node ` `# in the postorder traversal of` `# a given binary tree` `flag ``=` `[``0``]` `def` `NthPostordernode(root, N): `   `    ``if` `(root ``=``=` `None``):` `        ``return`   `    ``if` `(flag[``0``] <``=` `N[``0``]):` `        `  `        ``# left recursion ` `        ``NthPostordernode(root.left, N) `   `        ``# right recursion ` `        ``NthPostordernode(root.right, N) `   `        ``flag[``0``] ``+``=` `1`   `        ``# prints the n-th node of` `        ``# preorder traversal ` `        ``if` `(flag[``0``] ``=``=` `N[``0``]):` `            ``print``(root.data)` `                        `  `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``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``) `   `    ``N ``=` `[``6``] `   `    ``# prints n-th node found ` `    ``NthPostordernode(root, N)`   `# This code is contributed by ` `# SHUBHAMSINGH10`

## C#

 `// C# program to find n-th node of ` `// Postorder Traversal of Binary Tree ` `using` `System;`   `public` `class` `NthNodePostOrder ` `{`   `    ``/* A binary tree node structure */` `    ``public` `class` `Node ` `    ``{ ` `        ``public` `int` `data; ` `        ``public` `Node left, right; ` `        ``public` `Node(``int` `data)` `        ``{` `            ``this``.data=data;` `        ``}` `    ``}` `    ``static` `int` `flag = 0; `   `    ``// function to find the N-th node in the postorder ` `    ``// traversal of a given binary tree ` `    ``static` `void` `NthPostordernode(Node root, ``int` `N) ` `    ``{ ` `        ``if` `(root == ``null``) ` `            ``return``; ` `    `  `        ``if` `(flag <= N) ` `        ``{ ` `            ``// left recursion ` `            ``NthPostordernode(root.left, N); ` `            `  `            ``// right recursion ` `            ``NthPostordernode(root.right, N); ` `            ``flag++; ` `            `  `            ``// prints the n-th node of preorder traversal ` `            ``if` `(flag == N) ` `                ``Console.Write(root.data);` `        ``} ` `    ``} `   `    ``// Driver code` `    ``public` `static` `void` `Main(String []args)` `    ``{` `        ``Node root = ``new` `Node(25); ` `        ``root.left = ``new` `Node(20); ` `        ``root.right = ``new` `Node(30); ` `        ``root.left.left = ``new` `Node(18); ` `        ``root.left.right = ``new` `Node(22); ` `        ``root.right.left = ``new` `Node(24); ` `        ``root.right.right = ``new` `Node(32); ` `    `  `        ``int` `N = 6; ` `    `  `        ``// prints n-th node found ` `        ``NthPostordernode(root, N);` `    ``}` `}`   `// This code is contributed by Arnab Kundu`

## Javascript

 ``

Output

`30`

Complexity Analysis:

• Time Complexity: O(n)
Where n is the number of nodes in the given binary tree.
• Auxiliary Space: O(h)
Where h is the height of the tree. The extra space used is due to the recursion function call stack. In the worst case (if the tree is skewed) this can go upto O(n).

Iterative Approach:

The idea to solve this problem is to do iterative postorder 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.

Below is the implementation of the above approach:

## C++

 `// C++  program to find nth node of ` `// postorder traversal of Binary Tree` `#include ` `using` `namespace` `std;`   `// structure of Tree node` `struct` `Node {` `    ``int` `data;` `    ``Node *left, *right;` `};`   `// fun to create a new node` `Node* createNode(``int` `item)` `{` `    ``Node* temp = ``new` `Node();` `    ``temp->data = item;` `    ``temp->left = temp->right = NULL;` `    ``return` `temp;` `}`   `// fun to find nth node in the postorder traversal of a` `// given binary tree` `void` `Nthpostordernode(Node* root, ``int` `N)` `{` `    ``// base case` `    ``if` `(!root)` `        ``return``;`   `    ``int` `cnt = 0;`   `    ``stack s;` `    ``Node* curr = root;`   `    ``// do iterative postorder traversal as discussed in this` `    ``// post -` `    ``// (https://www.geeksforgeeks.org/iterative-postorder-traversal-using-stack/)` `    ``while` `(!s.empty() || curr != NULL) {`   `        ``// push all left nodes into stack` `        ``while` `(curr) {` `            ``s.push(curr);` `            ``curr = curr->left;` `        ``}`   `        ``Node* temp = s.top()->right;` `        ``// check if right node exists, if not make curr` `        ``// point to temp as we traverse first left nodes,` `        ``// then right nodes followed by root node` `        ``if` `(!temp) {` `            ``temp = s.top();` `            ``s.pop();`   `            ``// do cnt++ and check for the nth node` `            ``cnt++;` `            ``if` `(cnt == N) {` `                ``cout << temp->data << ``" "``;` `                ``return``;` `            ``}` `            ``while` `(!s.empty() && s.top()->right == temp) {` `                ``temp = s.top();` `                ``s.pop();` `                ``cnt++;` `                ``if` `(cnt == N) {` `                    ``cout << temp->data << ``" "``;` `                    ``return``;` `                ``}` `            ``}` `        ``}` `        ``else` `            ``curr = temp;` `    ``}` `}`   `// driver code` `int` `main()` `{` `    ``// create a 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);`   `    ``int` `N = 6;`   `    ``Nthpostordernode(root, N);`   `    ``return` `0;` `}` `// This code is contributed by Modem Upendra`

## Python

 `# python program to find nth node of` `# postorder traversal of binary tree` `# structure of tree node` `class` `Node:` `    ``def` `__init__(``self``, key):` `        ``self``.data ``=` `key` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`     `# function to create a new node` `def` `createNode(item):` `    ``temp ``=` `Node(item)` `    ``return` `temp`     `# function to find the nth node in the postorder traversal` `def` `Nthpostordernode(root, N):` `    ``# base case` `    ``if``(root ``is` `None``):` `        ``return`   `    ``cnt ``=` `0` `    ``s ``=` `[]` `    ``curr ``=` `root`   `    ``# do iterative postorder traversal` `    ``while``(``len``(s) > ``0` `or` `curr ``is` `not` `None``):` `        ``# push all left nodes into stack` `        ``while``(curr ``is` `not` `None``):` `            ``s.append(curr)` `            ``curr ``=` `curr.left`   `        ``temp ``=` `s[``len``(s) ``-` `1``].right` `        ``# check if right node exist, if not make curr` `        ``# point to temp as we traverse first left nodes,` `        ``# then right nodes followed by root node` `        ``if``(temp ``is` `None``):` `            ``temp ``=` `s.pop()`   `            ``# do cnt++ and check for the nth node` `            ``cnt ``=` `cnt``+``1` `            ``if``(cnt ``=``=` `N):` `                ``print``(temp.data)` `                ``return` `            ``while``(``len``(s) > ``0` `and` `s[``len``(s)``-``1``].right ``=``=` `temp):` `                ``temp ``=` `s.pop()` `                ``cnt ``+``=` `1` `                ``if``(cnt ``=``=` `N):` `                    ``print``(temp.data)` `                    ``return`   `        ``else``:` `            ``curr ``=` `temp`     `# driver code` `# create 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``)`   `N ``=` `6` `Nthpostordernode(root, N)`   `# this code is contributed by Kirti Agarwal`

## Javascript

 `// JavaScript program to find the nth node of` `// postorder traversal of binary tree`   `// structure of tree node` `class Node{` `    ``constructor(item){` `        ``this``.data = item;` `        ``this``.left = ``null``;` `        ``this``.right = ``null``;` `    ``}` `}`   `// function to create a new node` `function` `createNode(item){` `    ``return` `new` `Node(item);` `}`   `// function to find nth node in the postorder` `// traversal of a given binary tree` `function` `Nthpostordernode(root, N){` `    ``// base cas` `    ``if``(root == ``null``)` `        ``return``;` `    `  `    ``let cnt = 0;` `    `  `    ``let s = [];` `    ``let curr = root;` `    `  `    ``// do iterative postorder traversal` `    ``while``(s.length > 0 || curr != ``null``){` `        ``// push all left nodes into stack` `        ``while``(curr != ``null``){` `            ``s.push(curr);` `            ``curr = curr.left;` `        ``}` `        `  `        ``let temp = s[s.length - 1].right;` `        ``// check if right node exists, if not make curr` `        ``// point to temp as we traverse first left nodes,` `        ``// then right nodes followed by root node` `        ``if``(temp == ``null``){` `            ``temp = s.pop();` `            `  `            ``// do cnt++ and check for the nth node` `            ``cnt++;` `            ``if``(cnt == N){` `                ``document.write(temp.data + ``" "``) ;` `                ``return``;` `            ``}` `            ``while``(s.length > 0 && s[s.length-1].right == temp){` `                ``temp = s.pop();` `                ``cnt++;` `                ``if``(cnt == N){` `                    ``document.write(temp.data + ``" "``);` `                    ``return``;` `                ``}` `            ``}` `        ``}` `        ``else``{` `            ``curr = temp;` `        ``}` `    ``}` `}`   `// driver code` `let 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);`   `let N = 6;`   `Nthpostordernode(root, N);`   `// This code is contributed by Yash Agarwal(yashagarwal2852002)`

Output

`30 `

Complexity Analysis:

• Time Complexity: O(n)
Where n is the number of nodes in the given binary tree.
• Auxiliary Space: O(h)
Where h is the height of the tree. The extra space used is due to the recursion function call stack. In the worst case (if the tree is skewed) this can go upto O(n).

My Personal Notes arrow_drop_up
Related Articles