Skip to content
Related Articles

Related Articles

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

Improve Article
Save Article
  • Last Updated : 22 Jun, 2021
Improve Article
Save Article

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 <bits/stdc++.h>
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<Integer> 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<Integer> v = new Vector<Integer>();
 
    // 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




<script>
  
// JavaScript program to print paths with maximum
// element in the path greater than K
 
// A Binary Tree node
class Node
{
    constructor()
    {
        this.data = 0;
        this.left = null;
        this.right = null;
    }
};
 
var ans = 0;
 
// A utility function to create a new node
function newNode(data)
{
    var 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.
function findPathUtil(root, k, path, 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;
            document.write("(");
            for (var i = 0; i < path.length; i++)
            {
                document.write(path[i] + ", ");
            }
            document.write(root.data + "), ");
        }
        return;
    }
 
    // Append the node to the path vector
    path.push(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
function findPath(root, k)
{
    // Initialize flag
    var flag = 0;
 
    // ans is used to check empty condition
    ans = 0;
 
    var v = [];
 
    // Call function that print path
    findPathUtil(root, k, v, flag);
 
    // If the path doesn't exist
    if (ans == 0)
        document.write("-1");
}
 
// Driver code
var K = 25;
/* Constructing the following tree:
            10
        / \
        5     8
    / \ / \
    29 2 1 98
    /             \    
    20             50
  */
var 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);
 
 
</script>

Output: 

(10, 5, 29, 20), (10, 8, 98, 50),

 


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!