Related Articles

# Print all paths of the Binary Tree with maximum element in each path greater than or equal to K

• Last Updated : 22 Jun, 2021

Given a binary tree and an integer K, the task is to print the paths from root to leaf with the maximum element greater than or equal to K. Print -1 if there exists no such path.
Examples:

```Input: K = 25,
10
/    \
5      8
/   \   /  \
29    2 1    98
/               \
20                50

Output: (10, 5, 29, 20), (10, 8, 98, 50)
Explanation:
The maximum value in the path 10
-> 5 -> 29 -> 20
is 29 which is greater than 25.
The maximum value in the path 10
-> 8 -> 98 -> 50
is 98 which is greater than 25.

Input: K = 5
2
/   \
1     4
/
0

Output: -1
Explanation:
None of the paths from the root to a leaf
has the value greater than 5.```

Approach: The idea is to check if a node contains a value greater than or equal to ‘K’. If yes, then all the subtrees of that node is a valid path. The following steps can be followed to compute the answer:

• For every node, check if the current node value is greater than ‘K’ or not.
• If yes, then insert it into a vector and set a flag variable to 1. This signifies that all the paths going through this node will be printed.
• Repeat the above steps using recursion. The function is recursively called for the left and right subtrees.
• Finally, by using the concept of backtracking, print the path from the vector.

Below is the implementation of the above approach:

## CPP

 `// C++ program to print paths with maximum``// element in the path greater than K` `#include ``using` `namespace` `std;` `// A Binary Tree node``struct` `Node {``    ``int` `data;``    ``struct` `Node *left, *right;``};` `// A utility function to create a new node``struct` `Node* newNode(``int` `data)``{``    ``struct` `Node* newNode = ``new` `Node;``    ``newNode->data = data;``    ``newNode->left = newNode->right = NULL;``    ``return` `(newNode);``}` `// A recursive function to print the paths``// whose maximum element is greater than``// or equal to K.``void` `findPathUtil(Node* root, ``int` `k,``                  ``vector<``int``> path,``                  ``int` `flag, ``int``& ans)``{``    ``if` `(root == NULL)``        ``return``;` `    ``// If the current node value is greater than``    ``// or equal to k, then all the subtrees``    ``// following that node will get printed,``    ``// flag = 1 indicates to print the required path``    ``if` `(root->data >= k)``        ``flag = 1;` `    ``// If the leaf node is encountered, then the path is``    ``// printed if the size of the path vector is``    ``// greater than 0``    ``if` `(root->left == NULL && root->right == NULL) {``        ``if` `(flag == 1) {``            ``ans = 1;``            ``cout << ``"("``;``            ``for` `(``int` `i = 0; i < path.size(); i++) {``                ``cout << path[i] << ``", "``;``            ``}``            ``cout << root->data << ``"), "``;``        ``}``        ``return``;``    ``}` `    ``// Append the node to the path vector``    ``path.push_back(root->data);` `    ``// Recur left and right subtrees``    ``findPathUtil(root->left, k, path, flag, ans);``    ``findPathUtil(root->right, k, path, flag, ans);` `    ``// Backtracking to return the vector``    ``// and print the path if the flag is 1``    ``path.pop_back();``}` `// Function to initialize the variables``// and call the utility function to print``// the paths with maximum values greater than``// or equal to K``void` `findPath(Node* root, ``int` `k)``{``    ``// Initialize flag``    ``int` `flag = 0;` `    ``// ans is used to check empty condition``    ``int` `ans = 0;` `    ``vector<``int``> v;` `    ``// Call function that print path``    ``findPathUtil(root, k, v, flag, ans);` `    ``// If the path doesn't exist``    ``if` `(ans == 0)``        ``cout << ``"-1"``;``}` `// Driver code``int` `main(``void``)``{``    ``int` `K = 25;` `    ``/* Constructing the following tree:``                ``10``              ``/    \``             ``5      8``           ``/   \   /  \``          ``29    2 1    98``         ``/               \     ``        ``20                50``   ``*/` `    ``struct` `Node* root = newNode(10);``    ``root->left = newNode(5);``    ``root->right = newNode(8);``    ``root->left->left = newNode(29);``    ``root->left->right = newNode(2);``    ``root->right->right = newNode(98);``    ``root->right->left = newNode(1);``    ``root->right->right->right = newNode(50);``    ``root->left->left->left = newNode(20);` `    ``findPath(root, K);` `    ``return` `0;``}`

## Java

 `// Java program to print paths with maximum``// element in the path greater than K``import` `java.util.*;` `class` `GFG``{` `// A Binary Tree node``static` `class` `Node``{``    ``int` `data;``    ``Node left, right;``};``static` `int` `ans;` `// A utility function to create a new node``static` `Node newNode(``int` `data)``{``    ``Node newNode = ``new` `Node();``    ``newNode.data = data;``    ``newNode.left = newNode.right = ``null``;``    ``return` `(newNode);``}` `// A recursive function to print the paths``// whose maximum element is greater than``// or equal to K.``static` `void` `findPathUtil(Node root, ``int` `k,``                ``Vector path,``                ``int` `flag)``{``    ``if` `(root == ``null``)``        ``return``;` `    ``// If the current node value is greater than``    ``// or equal to k, then all the subtrees``    ``// following that node will get printed,``    ``// flag = 1 indicates to print the required path``    ``if` `(root.data >= k)``        ``flag = ``1``;` `    ``// If the leaf node is encountered, then the path is``    ``// printed if the size of the path vector is``    ``// greater than 0``    ``if` `(root.left == ``null` `&& root.right == ``null``)``    ``{``        ``if` `(flag == ``1``)``        ``{``            ``ans = ``1``;``            ``System.out.print(``"("``);``            ``for` `(``int` `i = ``0``; i < path.size(); i++)``            ``{``                ``System.out.print(path.get(i)+ ``", "``);``            ``}``            ``System.out.print(root.data+ ``"), "``);``        ``}``        ``return``;``    ``}` `    ``// Append the node to the path vector``    ``path.add(root.data);` `    ``// Recur left and right subtrees``    ``findPathUtil(root.left, k, path, flag);``    ``findPathUtil(root.right, k, path, flag);` `    ``// Backtracking to return the vector``    ``// and print the path if the flag is 1``    ``path.remove(path.size()-``1``);``}` `// Function to initialize the variables``// and call the utility function to print``// the paths with maximum values greater than``// or equal to K``static` `void` `findPath(Node root, ``int` `k)``{``    ``// Initialize flag``    ``int` `flag = ``0``;` `    ``// ans is used to check empty condition``    ``ans = ``0``;` `    ``Vector v = ``new` `Vector();` `    ``// Call function that print path``    ``findPathUtil(root, k, v, flag);` `    ``// If the path doesn't exist``    ``if` `(ans == ``0``)``        ``System.out.print(``"-1"``);``}` `// Driver code``public` `static` `void` `main(String [] args)``{``    ``int` `K = ``25``;` `    ``/* Constructing the following tree:``                ``10``            ``/ \``            ``5     8``        ``/ \ / \``        ``29 2 1 98``        ``/             \    ``        ``20             50``*/` `    ``Node root = newNode(``10``);``    ``root.left = newNode(``5``);``    ``root.right = newNode(``8``);``    ``root.left.left = newNode(``29``);``    ``root.left.right = newNode(``2``);``    ``root.right.right = newNode(``98``);``    ``root.right.left = newNode(``1``);``    ``root.right.right.right = newNode(``50``);``    ``root.left.left.left = newNode(``20``);` `    ``findPath(root, K);``}``}` `// This code is contributed by PrinciRaj1992`

## Python3

 `# Python3 program to construct string from binary tree` `# A Binary Tree node``class` `Node:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# A recursive function to print the paths``# whose maximum element is greater than``# or equal to K.``def` `findPathUtil(root: Node, k: ``int``, path: ``list``, flag: ``int``):``    ``global` `ans` `    ``if` `root ``is` `None``:``        ``return` `    ``# If the current node value is greater than``    ``# or equal to k, then all the subtrees``    ``# following that node will get printed,``    ``# flag = 1 indicates to print the required path``    ``if` `root.data >``=` `k:``        ``flag ``=` `1` `    ``# If the leaf node is encountered, then the path is``    ``# printed if the size of the path vector is``    ``# greater than 0``    ``if` `root.left ``is` `None` `and` `root.right ``is` `None``:``        ``if` `flag:``            ``ans ``=` `1``            ``print``(``"("``, end ``=` `"")``            ``for` `i ``in` `range``(``len``(path)):``                ``print``(path[i], end ``=` `", "``)``            ``print``(root.data, end ``=` `"), "``)``        ``return` `    ``# Append the node to the path vector``    ``path.append(root.data)` `    ``# Recur left and right subtrees``    ``findPathUtil(root.left, k, path, flag)``    ``findPathUtil(root.right, k, path, flag)` `    ``# Backtracking to return the vector``    ``# and print the path if the flag is 1``    ``path.pop()` `# Function to initialize the variables``# and call the utility function to print``# the paths with maximum values greater than``# or equal to K``def` `findPath(root: Node, k: ``int``):``    ``global` `ans` `    ``# Initialize flag``    ``flag ``=` `0` `    ``# ans is used to check empty condition``    ``ans ``=` `0` `    ``v ``=` `[]` `    ``# Call function that print path``    ``findPathUtil(root, k, v, flag)` `    ``# If the path doesn't exist``    ``if` `ans ``=``=` `0``:``        ``print``(``-``1``)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``ans ``=` `0``    ``k ``=` `25` `    ``# Constructing the following tree:``    ``#             10``    ``#         / \``    ``#         5     8``    ``#     / \ / \``    ``#     29 2 1 98``    ``#     /             \``    ``#     20             50` `    ``root ``=` `Node(``10``)``    ``root.left ``=` `Node(``5``)``    ``root.right ``=` `Node(``8``)``    ``root.left.left ``=` `Node(``29``)``    ``root.left.right ``=` `Node(``2``)``    ``root.right.right ``=` `Node(``98``)``    ``root.right.left ``=` `Node(``1``)``    ``root.right.right.right ``=` `Node(``50``)``    ``root.left.left.left ``=` `Node(``20``)` `    ``findPath(root, k)` `# This code is contributed by``# sanjeev2552`

## C#

 `// C# program to print paths with maximum``// element in the path greater than K``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `// A Binary Tree node``class` `Node``{``    ``public` `int` `data;``    ``public` `Node left, right;``};``static` `int` `ans;` `// A utility function to create a new node``static` `Node newNode(``int` `data)``{``    ``Node newNode = ``new` `Node();``    ``newNode.data = data;``    ``newNode.left = newNode.right = ``null``;``    ``return` `(newNode);``}` `// A recursive function to print the paths``// whose maximum element is greater than``// or equal to K.``static` `void` `findPathUtil(Node root, ``int` `k,``                        ``List<``int``> path,``                        ``int` `flag)``{``    ``if` `(root == ``null``)``        ``return``;` `    ``// If the current node value is greater than``    ``// or equal to k, then all the subtrees``    ``// following that node will get printed,``    ``// flag = 1 indicates to print the required path``    ``if` `(root.data >= k)``        ``flag = 1;` `    ``// If the leaf node is encountered, then the path is``    ``// printed if the size of the path vector is``    ``// greater than 0``    ``if` `(root.left == ``null` `&& root.right == ``null``)``    ``{``        ``if` `(flag == 1)``        ``{``            ``ans = 1;``            ``Console.Write(``"("``);``            ``for` `(``int` `i = 0; i < path.Count; i++)``            ``{``                ``Console.Write(path[i] + ``", "``);``            ``}``            ``Console.Write(root.data + ``"), "``);``        ``}``        ``return``;``    ``}` `    ``// Append the node to the path vector``    ``path.Add(root.data);` `    ``// Recur left and right subtrees``    ``findPathUtil(root.left, k, path, flag);``    ``findPathUtil(root.right, k, path, flag);` `    ``// Backtracking to return the vector``    ``// and print the path if the flag is 1``    ``path.RemoveAt(path.Count-1);``}` `// Function to initialize the variables``// and call the utility function to print``// the paths with maximum values greater than``// or equal to K``static` `void` `findPath(Node root, ``int` `k)``{``    ``// Initialize flag``    ``int` `flag = 0;` `    ``// ans is used to check empty condition``    ``ans = 0;` `    ``List<``int``> v = ``new` `List<``int``>();` `    ``// Call function that print path``    ``findPathUtil(root, k, v, flag);` `    ``// If the path doesn't exist``    ``if` `(ans == 0)``        ``Console.Write(``"-1"``);``}` `// Driver code``public` `static` `void` `Main(String [] args)``{``    ``int` `K = 25;` `    ``/* Constructing the following tree:``                ``10``            ``/ \``            ``5     8``        ``/ \ / \``        ``29 2 1 98``        ``/             \    ``        ``20             50``*/` `    ``Node root = newNode(10);``    ``root.left = newNode(5);``    ``root.right = newNode(8);``    ``root.left.left = newNode(29);``    ``root.left.right = newNode(2);``    ``root.right.right = newNode(98);``    ``root.right.left = newNode(1);``    ``root.right.right.right = newNode(50);``    ``root.left.left.left = newNode(20);` `    ``findPath(root, K);``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``
Output:
`(10, 5, 29, 20), (10, 8, 98, 50),`

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up