 GFG App
Open App Browser
Continue

# Print Ancestors of a given node in Binary Tree

Given a Binary Tree and a key, write a function that prints all the ancestors of the key in the given binary tree.

For example, if the given tree is following Binary Tree and the key is 7, then your function should print 4, 2, and 1.

```              1
/   \
2      3
/  \
4     5
/
7```
Recommended Practice

Thanks to Mike, Sambasiva and wgpshashank for their contribution.

## C++

 `// C++ program to print ancestors of given node` `#include`   `using` `namespace` `std;`   `/* A binary tree node has data, pointer to left child` `   ``and a pointer to right child */` `struct` `node` `{` `   ``int` `data;` `   ``struct` `node* left;` `   ``struct` `node* right;` `};`   `/* If target is present in tree, then prints the ancestors` `   ``and returns true, otherwise returns false. */` `bool` `printAncestors(``struct` `node *root, ``int` `target)` `{` `  ``/* base cases */` `  ``if` `(root == NULL)` `     ``return` `false``;`   `  ``if` `(root->data == target)` `     ``return` `true``;`   `  ``/* If target is present in either left or right subtree of this node,` `     ``then print this node */` `  ``if` `( printAncestors(root->left, target) ||` `       ``printAncestors(root->right, target) )` `  ``{` `    ``cout << root->data << ``" "``;` `    ``return` `true``;` `  ``}`   `  ``/* Else return false */` `  ``return` `false``;` `}`   `/* Helper function that allocates a new node with the` `   ``given data and NULL left and right pointers. */` `struct` `node* newnode(``int` `data)` `{` `  ``struct` `node* node = (``struct` `node*)` `                       ``malloc``(``sizeof``(``struct` `node));` `  ``node->data = data;` `  ``node->left = NULL;` `  ``node->right = NULL;`   `  ``return``(node);` `}`   `/* Driver program to test above functions*/` `int` `main()` `{`   `  ``/* Construct the following binary tree` `              ``1` `            ``/   \` `          ``2      3` `        ``/  \` `      ``4     5` `     ``/` `    ``7` `  ``*/` `  ``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->left  = newnode(7);`   `  ``printAncestors(root, 7);`   `  ``getchar``();` `  ``return` `0;` `}`

## Java

 `// Java program to print ancestors of given node` ` `  `/* A binary tree node has data, pointer to left child` `   ``and a pointer to right child */` `class` `Node ` `{` `    ``int` `data;` `    ``Node left, right, nextRight;` ` `  `    ``Node(``int` `item) ` `    ``{` `        ``data = item;` `        ``left = right = nextRight = ``null``;` `    ``}` `}` ` `  `class` `BinaryTree ` `{` `    ``Node root;` ` `  `    ``/* If target is present in tree, then prints the ancestors` `       ``and returns true, otherwise returns false. */` `    ``boolean` `printAncestors(Node node, ``int` `target) ` `    ``{` `         ``/* base cases */` `        ``if` `(node == ``null``)` `            ``return` `false``;` ` `  `        ``if` `(node.data == target)` `            ``return` `true``;` ` `  `        ``/* If target is present in either left or right subtree ` `           ``of this node, then print this node */` `        ``if` `(printAncestors(node.left, target)` `                ``|| printAncestors(node.right, target)) ` `        ``{` `            ``System.out.print(node.data + ``" "``);` `            ``return` `true``;` `        ``}` ` `  `        ``/* Else return false */` `        ``return` `false``;` `    ``}` ` `  `    ``/* Driver program to test above functions */` `    ``public` `static` `void` `main(String args[]) ` `    ``{` `        ``BinaryTree tree = ``new` `BinaryTree();` `        `  `        ``/* Construct the following binary tree` `                  ``1` `                ``/   \` `               ``2     3` `              ``/  \` `             ``4    5` `            ``/` `           ``7` `        ``*/` `        ``tree.root = ``new` `Node(``1``);` `        ``tree.root.left = ``new` `Node(``2``);` `        ``tree.root.right = ``new` `Node(``3``);` `        ``tree.root.left.left = ``new` `Node(``4``);` `        ``tree.root.left.right = ``new` `Node(``5``);` `        ``tree.root.left.left.left = ``new` `Node(``7``);` ` `  `        ``tree.printAncestors(tree.root, ``7``);` ` `  `    ``}` `}` ` `  `// This code has been contributed by Mayank Jaiswal`

## Python3

 `# Python program to print ancestors of given node in` `# binary tree`   `# A Binary Tree node` `class` `Node:`   `    ``# Constructor to create a new node` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# If target is present in tree, then prints the ancestors` `# and returns true, otherwise returns false` `def` `printAncestors(root, target):` `    `  `    ``# Base case` `    ``if` `root ``=``=` `None``:` `        ``return` `False` `    `  `    ``if` `root.data ``=``=` `target:` `        ``return` `True`   `    ``# If target is present in either left or right subtree ` `    ``# of this node, then print this node` `    ``if` `(printAncestors(root.left, target) ``or` `        ``printAncestors(root.right, target)):` `        ``print``(root.data,end``=``' '``)` `        ``return` `True`   `    ``# Else return False ` `    ``return` `False`   `# Driver program to test above function` `root ``=` `Node(``1``)` `root.left ``=` `Node(``2``)` `root.right ``=` `Node(``3``)` `root.left.left ``=` `Node(``4``)` `root.left.right ``=` `Node(``5``)` `root.left.left.left ``=` `Node(``7``)`   `printAncestors(root, ``7``)`   `# This code is contributed by Nikhil Kumar Singh(nickzuck_007)`

## C#

 `using` `System;`   `// C# program to print ancestors of given node `   `/* A binary tree node has data, pointer to left child ` `and a pointer to right child */` `public` `class` `Node` `{` `    ``public` `int` `data;` `    ``public` `Node left, right, nextRight;`   `    ``public` `Node(``int` `item)` `    ``{` `        ``data = item;` `        ``left = right = nextRight = ``null``;` `    ``}` `}`   `public` `class` `BinaryTree` `{` `    ``public` `Node root;`   `    ``/* If target is present in tree, then prints the ancestors ` `    ``and returns true, otherwise returns false. */` `    ``public` `virtual` `bool` `printAncestors(Node node, ``int` `target)` `    ``{` `        ``/* base cases */` `        ``if` `(node == ``null``)` `        ``{` `            ``return` `false``;` `        ``}`   `        ``if` `(node.data == target)` `        ``{` `            ``return` `true``;` `        ``}`   `        ``/* If target is present in either left or right subtree ` `        ``of this node, then print this node */` `        ``if` `(printAncestors(node.left, target) ` `        ``|| printAncestors(node.right, target))` `        ``{` `            ``Console.Write(node.data + ``" "``);` `            ``return` `true``;` `        ``}`   `        ``/* Else return false */` `        ``return` `false``;` `    ``}`   `    ``/* Driver program to test above functions */` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``BinaryTree tree = ``new` `BinaryTree();`   `        ``/* Construct the following binary tree ` `                ``1 ` `                ``/ \ ` `            ``2     3 ` `            ``/ \ ` `            ``4 5 ` `            ``/ ` `        ``7 ` `        ``*/` `        ``tree.root = ``new` `Node(1);` `        ``tree.root.left = ``new` `Node(2);` `        ``tree.root.right = ``new` `Node(3);` `        ``tree.root.left.left = ``new` `Node(4);` `        ``tree.root.left.right = ``new` `Node(5);` `        ``tree.root.left.left.left = ``new` `Node(7);`   `        ``tree.printAncestors(tree.root, 7);`   `    ``}` `}`   `// This code is contributed by Shrikant13`

## Javascript

 ``

Output

`4 2 1 `

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 given Binary Tree

### Another Approach :

An alternative approach to solving this problem is by using an iterative approach with a stack data structure.

1. We start by creating an empty stack to store the nodes.
2. We enter a while loop that continues until the current node is NULL and the stack is empty.
3. Inside the loop, we traverse the left subtree of the current node, pushing each encountered node onto the stack until we reach a leaf node or find the target node.
4. If we find the target node, we break out of the loop.
5. If the current node is NULL and the stack is not empty, it means we have finished processing the left subtree and need to backtrack to the parent nodes.
6. We check if the right child of the top node on the stack is NULL or if it has already been processed. If so, it indicates that we have finished processing that node        and its subtree.
7. In such cases, we print the top node’s data (which represents an ancestor) and pop it from the stack.
8. We continue this process until we find a node whose right child has not been processed.
9. Once we finish processing the left subtree and backtrack to the current node’s right child, we update the current node accordingly.
a) If the stack is not empty, we set the current node to the right child of the top node on the stack.
b) If the stack is empty, it means we have finished traversing the entire tree, and we set the current node to NULL.
10. Finally, if the stack is not empty, we print the contents of the stack, which represents the ancestors of the target node.
11. If the stack is empty, it means the target node was not found, and we return false.

This iterative approach simulates the recursive approach by using a stack to keep track of the nodes and their respective subtrees as we traverse the tree. It eliminates the need for recursive function calls and utilizes the stack to manage the backtracking process.

Both the recursive and iterative approaches achieve the same goal of finding and printing the ancestors of a given node in a binary tree.

## C++

 `#include` `using` `namespace` `std;`   `/* A binary tree node has data, pointer to left child` `   ``and a pointer to right child */` `struct` `node` `{` `   ``int` `data;` `   ``struct` `node* left;` `   ``struct` `node* right;` `};`   `/* If target is present in tree, then prints the ancestors` `   ``and returns true, otherwise returns false. */` `bool` `printAncestors(``struct` `node *root, ``int` `target)` `{` `    ``stack st;` `    ``while` `(root || !st.empty()) {` `        ``while` `(root && root->data != target) {` `            ``st.push(root);` `            ``root = root->left;` `        ``}` `        `  `        ``if` `(root && root->data == target)` `            ``break``;` `        `  `        ``if` `(!st.empty() && st.top()->right == NULL) {` `            ``root = st.top();` `            ``st.pop();` `            `  `            ``while` `(!st.empty() && st.top()->right == root) {` `                ``root = st.top();` `                ``st.pop();` `            ``}` `        ``}` `        `  `        ``root = (!st.empty()) ? st.top()->right : NULL;` `    ``}` `    `  `    ``if` `(!st.empty()) {` `        ``while` `(!st.empty()) {` `            ``cout << st.top()->data << ``" "``;` `            ``st.pop();` `        ``}` `        ``return` `true``;` `    ``}` `    `  `    ``return` `false``;` `}`   `/* Helper function that allocates a new node with the` `   ``given data and NULL left and right pointers. */` `struct` `node* newnode(``int` `data)` `{` `  ``struct` `node* node = (``struct` `node*)``malloc``(``sizeof``(``struct` `node));` `  ``node->data = data;` `  ``node->left = NULL;` `  ``node->right = NULL;`   `  ``return``(node);` `}`   `/* Driver program to test above functions*/` `int` `main()` `{` `  ``/* Construct the following binary tree` `              ``1` `            ``/   \` `          ``2      3` `        ``/  \` `      ``4     5` `     ``/` `    ``7` `  ``*/` `  ``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->left = newnode(7);`   `  ``printAncestors(root, 7);`   `  ``return` `0;` `}`

Output

`4 2 1 `
• 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 given Binary Tree

My Personal Notes arrow_drop_up