Given a Binary tree, the task is to print all possible root-to-leaf paths having a maximum number of even valued nodes.
Examples:
Input:
2 / \ 6 3 / \ \ 4 7 11 / \ \ 10 12 1Output:
2 -> 6 -> 4 -> 10
2 -> 6 -> 4 -> 12
Explanation:
Count of even nodes on the path 2 -> 6 -> 4 -> 10 = 4
Count of even nodes on the path 2 -> 6 -> 4 -> 12 = 4
Count of even nodes on the path 2 -> 6 -> 7 -> 1 = 2
Count of even nodes on the path 2 -> 3 -> 11 = 1
Therefore, the paths consisting of maximum count of even nodes are {2 -> 6 -> 4 -> 10} and {2 -> 6 -> 4 -> 12 }.Input:
5 / \ 6 3 / \ \ 4 9 2Output: 5 -> 6 -> 4.
Approach: The problem can be solved using Preorder Traversal. The idea is to traverse the given Binary Tree and find the maximum count of even nodes possible in a root-to-leaf path. Finally, traverse the tree and print all possible root-to-leaf paths having the maximum count of even nodes. Follow the steps below to solve the problem:
- Initialize two variables, say cntMaxEven and cntEven to store the maximum count of even nodes from the root to a leaf node and count of even nodes from root to a leaf node.
-
Traverse the tree and check the following conditions:
- Check if current node is a leaf node and cntEven > cntMaxEven or not. If found to be true then update cntMaxEven = cntEven.
- Otherwise, check if the current node is an even node or not. If found to be true, then Update cntEven += 1.
- Finally, traverse the tree and print all possible root-to-leaf paths having a count of even nodes equal to cntMaxEven.
// C++ program to implement // the above approach #include <bits/stdc++.h> using namespace std;
// Structure of the binary tree struct Node {
// Stores data
int data;
// Stores left child
Node* left;
// Stores right child
Node* right;
// Initialize a node
// of binary tree
Node( int val)
{
// Update data;
data = val;
left = right = NULL;
}
}; // Function to find maximum count // of even nodes in a path int cntMaxEvenNodes(Node* root)
{ // If the tree is an
// empty binary tree.
if (root == NULL) {
return 0;
}
// Stores count of even nodes
// in current subtree
int cntEven = 0;
// If root node is
// an even node
if (root->data % 2
== 0) {
// Update cntEven
cntEven += 1;
}
// Stores count of even nodes
// in left subtree.
int X = cntMaxEvenNodes(
root->left);
// Stores count of even nodes
// in right subtree.
int Y = cntMaxEvenNodes(
root->right);
// cntEven
cntEven += max(X, Y);
return cntEven;
} // Function to print paths having // count of even nodes equal // to maximum count of even nodes void printPath(Node* root, int cntEven,
int cntMaxEven,
vector< int >& path)
{ // If the tree is an
// empty Binary Tree
if (root == NULL) {
return ;
}
// If current node value is even
if (root->data % 2 == 0) {
path.push_back(
root->data);
cntEven += 1;
}
// If current node is
// a leaf node
if (root->left == NULL
&& root->right == NULL) {
// If count of even nodes in
// path is equal to cntMaxEven
if (cntEven == cntMaxEven) {
// Stores length of path
int N = path.size();
// Print path
for ( int i = 0; i < N - 1;
i++) {
cout << path[i] << " -> " ;
}
cout << path[N - 1] << endl;
}
}
// Left subtree
printPath(root->left, cntEven,
cntMaxEven, path);
// Right subtree
printPath(root->right, cntEven,
cntMaxEven, path);
// If current node is even
if (root->data % 2 == 0) {
path.pop_back();
// Update cntEven
cntEven--;
}
} // Utility Function to print path // from root to leaf node having // maximum count of even nodes void printMaxPath(Node* root)
{ // Stores maximum count of even
// nodes of a path in the tree
int cntMaxEven;
cntMaxEven
= cntMaxEvenNodes(root);
// Stores path of tree having
// even nodes
vector< int > path;
printPath(root, 0, cntMaxEven,
path);
} // Driver code int main()
{ // Create tree.
Node* root = NULL;
root = new Node(2);
root->left = new Node(6);
root->right = new Node(3);
root->left->left = new Node(4);
root->left->right = new Node(7);
root->right->right = new Node(11);
root->left->left->left = new Node(10);
root->left->left->right = new Node(12);
root->left->right->right = new Node(1);
printMaxPath(root);
} |
// Java program to implement // the above approach import java.util.*;
class GFG{
// Structure of the binary tree static class Node
{ // Stores data
int data;
// Stores left child
Node left;
// Stores right child
Node right;
// Initialize a node
// of binary tree
Node( int val)
{
// Update data;
data = val;
left = right = null ;
}
}; // Function to find maximum count // of even nodes in a path static int cntMaxEvenNodes(Node root)
{ // If the tree is an
// empty binary tree.
if (root == null )
{
return 0 ;
}
// Stores count of even nodes
// in current subtree
int cntEven = 0 ;
// If root node is
// an even node
if (root.data % 2 == 0 )
{
// Update cntEven
cntEven += 1 ;
}
// Stores count of even nodes
// in left subtree.
int X = cntMaxEvenNodes(root.left);
// Stores count of even nodes
// in right subtree.
int Y = cntMaxEvenNodes(root.right);
// cntEven
cntEven += Math.max(X, Y);
return cntEven;
} // Function to print paths having // count of even nodes equal // to maximum count of even nodes static void printPath(Node root, int cntEven,
int cntMaxEven,
Vector<Integer> path)
{ // If the tree is an
// empty Binary Tree
if (root == null )
{
return ;
}
// If current node value is even
if (root.data % 2 == 0 )
{
path.add(root.data);
cntEven += 1 ;
}
// If current node is
// a leaf node
if (root.left == null &&
root.right == null )
{
// If count of even nodes in
// path is equal to cntMaxEven
if (cntEven == cntMaxEven)
{
// Stores length of path
int N = path.size();
// Print path
for ( int i = 0 ; i < N - 1 ; i++)
{
System.out.print(path.get(i) + " -> " );
}
System.out.print(path.get(N - 1 ) + "\n" );
}
}
// Left subtree
printPath(root.left, cntEven,
cntMaxEven, path);
// Right subtree
printPath(root.right, cntEven,
cntMaxEven, path);
// If current node is even
if (root.data % 2 == 0 )
{
path.remove(path.size() - 1 );
// Update cntEven
cntEven--;
}
} // Utility Function to print path // from root to leaf node having // maximum count of even nodes static void printMaxPath(Node root)
{ // Stores maximum count of even
// nodes of a path in the tree
int cntMaxEven;
cntMaxEven = cntMaxEvenNodes(root);
// Stores path of tree having
// even nodes
Vector<Integer> path = new Vector<>();
printPath(root, 0 , cntMaxEven,
path);
} // Driver code public static void main(String[] args)
{ // Create tree.
Node root = null ;
root = new Node( 2 );
root.left = new Node( 6 );
root.right = new Node( 3 );
root.left.left = new Node( 4 );
root.left.right = new Node( 7 );
root.right.right = new Node( 11 );
root.left.left.left = new Node( 10 );
root.left.left.right = new Node( 12 );
root.left.right.right = new Node( 1 );
printMaxPath(root);
} } // This code is contributed by Amit Katiyar |
# Python3 program to implement # the above approach # Structure of the binary tree class newNode:
def __init__( self , val):
self .data = val
self .left = None
self .right = None
path = []
# Function to find maximum count # of even nodes in a path def cntMaxEvenNodes(root):
# If the tree is an
# empty binary tree.
if (root = = None ):
return 0
# Stores count of even nodes
# in current subtree
cntEven = 0
# If root node is
# an even node
if (root.data % 2 = = 0 ):
# Update cntEven
cntEven + = 1
# Stores count of even nodes
# in left subtree.
X = cntMaxEvenNodes(root.left)
# Stores count of even nodes
# in right subtree.
Y = cntMaxEvenNodes(root.right)
# cntEven
cntEven + = max (X, Y)
return cntEven
# Function to print paths having # count of even nodes equal # to maximum count of even nodes def printPath(root, cntEven, cntMaxEven):
global path
# If the tree is an
# empty Binary Tree
if (root = = None ):
return
# If current node value is even
if (root.data % 2 = = 0 ):
path.append(root.data)
cntEven + = 1
# If current node is
# a leaf node
if (root.left = = None and
root.right = = None ):
# If count of even nodes in
# path is equal to cntMaxEven
if (cntEven = = cntMaxEven):
# Stores length of path
N = len (path)
# Print path
for i in range (N - 1 ):
print (path[i], end = "->" )
print (path[N - 1 ])
# Left subtree
printPath(root.left, cntEven, cntMaxEven)
# Right subtree
printPath(root.right, cntEven, cntMaxEven)
# If current node is even
if (root.data % 2 = = 0 ):
path.remove(path[ len (path) - 1 ])
# Update cntEven
cntEven - = 1
# Utility Function to print path # from root to leaf node having # maximum count of even nodes def printMaxPath(root):
global path
# Stores maximum count of even
# nodes of a path in the tree
cntMaxEven = cntMaxEvenNodes(root)
printPath(root, 0 , cntMaxEven)
# Driver code if __name__ = = '__main__' :
# Create tree.
root = None
root = newNode( 2 )
root.left = newNode( 6 )
root.right = newNode( 3 )
root.left.left = newNode( 4 )
root.left.right = newNode( 7 )
root.right.right = newNode( 11 )
root.left.left.left = newNode( 10 )
root.left.left.right = newNode( 12 )
root.left.right.right = newNode( 1 )
printMaxPath(root)
# This code is contributed by bgangwar59 |
// C# program to implement // the above approach using System;
using System.Collections.Generic;
class GFG{
// Structure of the binary tree class Node
{ // Stores data
public int data;
// Stores left child
public Node left;
// Stores right child
public Node right;
// Initialize a node
// of binary tree
public Node( int val)
{
// Update data;
data = val;
left = right = null ;
}
}; // Function to find maximum count // of even nodes in a path static int cntMaxEvenNodes(Node root)
{ // If the tree is an
// empty binary tree.
if (root == null )
{
return 0;
}
// Stores count of even
// nodes in current subtree
int cntEven = 0;
// If root node is
// an even node
if (root.data % 2 == 0)
{
// Update cntEven
cntEven += 1;
}
// Stores count of even
// nodes in left subtree.
int X = cntMaxEvenNodes(root.left);
// Stores count of even nodes
// in right subtree.
int Y = cntMaxEvenNodes(root.right);
// cntEven
cntEven += Math.Max(X, Y);
return cntEven;
} // Function to print paths having // count of even nodes equal // to maximum count of even nodes static void printPath(Node root,
int cntEven,
int cntMaxEven,
List< int > path)
{ // If the tree is an
// empty Binary Tree
if (root == null )
{
return ;
}
// If current node value
// is even
if (root.data % 2 == 0)
{
path.Add(root.data);
cntEven += 1;
}
// If current node is
// a leaf node
if (root.left == null &&
root.right == null )
{
// If count of even nodes in
// path is equal to cntMaxEven
if (cntEven == cntMaxEven)
{
// Stores length of path
int N = path.Count;
// Print path
for ( int i = 0;
i < N - 1; i++)
{
Console.Write(path[i] +
" -> " );
}
Console.Write(path[N - 1] +
"\n" );
}
}
// Left subtree
printPath(root.left, cntEven,
cntMaxEven, path);
// Right subtree
printPath(root.right, cntEven,
cntMaxEven, path);
// If current node is even
if (root.data % 2 == 0)
{
path.RemoveAt(path.Count - 1);
// Update cntEven
cntEven--;
}
} // Utility Function to print path // from root to leaf node having // maximum count of even nodes static void printMaxPath(Node root)
{ // Stores maximum count of even
// nodes of a path in the tree
int cntMaxEven;
cntMaxEven = cntMaxEvenNodes(root);
// Stores path of tree having
// even nodes
List< int > path = new List< int >();
printPath(root, 0,
cntMaxEven, path);
} // Driver code public static void Main(String[] args)
{ // Create tree.
Node root = null ;
root = new Node(2);
root.left = new Node(6);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(7);
root.right.right = new Node(11);
root.left.left.left = new Node(10);
root.left.left.right = new Node(12);
root.left.right.right = new Node(1);
printMaxPath(root);
} } // This code is contributed by Princi Singh |
<script> // Javascript program to implement // the above approach // Structure of the binary tree class Node { constructor(val)
{
this .left = null ;
this .right = null ;
this .data = val;
}
} // Function to find maximum count // of even nodes in a path function cntMaxEvenNodes(root)
{ // If the tree is an
// empty binary tree.
if (root == null )
{
return 0;
}
// Stores count of even nodes
// in current subtree
let cntEven = 0;
// If root node is
// an even node
if (root.data % 2 == 0)
{
// Update cntEven
cntEven += 1;
}
// Stores count of even nodes
// in left subtree.
let X = cntMaxEvenNodes(root.left);
// Stores count of even nodes
// in right subtree.
let Y = cntMaxEvenNodes(root.right);
// cntEven
cntEven += Math.max(X, Y);
return cntEven;
} // Function to print paths having // count of even nodes equal // to maximum count of even nodes function printPath(root, cntEven,
cntMaxEven, path)
{ // If the tree is an
// empty Binary Tree
if (root == null )
{
return ;
}
// If current node value is even
if (root.data % 2 == 0)
{
path.push(root.data);
cntEven += 1;
}
// If current node is
// a leaf node
if (root.left == null &&
root.right == null )
{
// If count of even nodes in
// path is equal to cntMaxEven
if (cntEven == cntMaxEven)
{
// Stores length of path
let N = path.length;
// Print path
for (let i = 0; i < N - 1; i++)
{
document.write(path[i] + " -> " );
}
document.write(path[N - 1] + "</br>" );
}
}
// Left subtree
printPath(root.left, cntEven,
cntMaxEven, path);
// Right subtree
printPath(root.right, cntEven,
cntMaxEven, path);
// If current node is even
if (root.data % 2 == 0)
{
path.pop();
// Update cntEven
cntEven--;
}
} // Utility Function to print path // from root to leaf node having // maximum count of even nodes function printMaxPath(root)
{ // Stores maximum count of even
// nodes of a path in the tree
let cntMaxEven;
cntMaxEven = cntMaxEvenNodes(root);
// Stores path of tree having
// even nodes
let path = [];
printPath(root, 0, cntMaxEven, path);
} // Driver code // Create tree. let root = null ;
root = new Node(2);
root.left = new Node(6);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(7);
root.right.right = new Node(11);
root.left.left.left = new Node(10);
root.left.left.right = new Node(12);
root.left.right.right = new Node(1);
printMaxPath(root); // This code is contributed by suresh07 </script> |
2 -> 6 -> 4 -> 10 2 -> 6 -> 4 -> 12
Time Complexity: O(N), where N is the number of nodes in the binary tree.
Auxiliary Space: O(N)