Print the longest leaf to leaf path in a Binary tree
C++
// C++ program to print the longest leaf to leaf // path #include <bits/stdc++.h> using namespace std; // Tree node structure used in the program struct Node { int data; Node *left, *right; }; struct Node* newNode( int data) { struct Node* node = new Node; node->data = data; node->left = node->right = NULL; return (node); } // Function to find height of a tree int height(Node* root, int & ans, Node*(&k), int & lh, int & rh, int & f) { if (root == NULL) return 0; int left_height = height(root->left, ans, k, lh, rh, f); int right_height = height(root->right, ans, k, lh, rh, f); // update the answer, because diameter of a // tree is nothing but maximum value of // (left_height + right_height + 1) for each node if (ans < 1 + left_height + right_height) { ans = 1 + left_height + right_height; // save the root, this will help us finding the // left and the right part of the diameter k = root; // save the height of left & right subtree as well. lh = left_height; rh = right_height; } return 1 + max(left_height, right_height); } // prints the root to leaf path void printArray( int ints[], int len, int f) { int i; // print left part of the path in reverse order if (f == 0) { for (i = len - 1; i >= 0; i--) { printf ( "%d " , ints[i]); } } // print right part of the path else if (f == 1) { for (i = 0; i < len; i++) { printf ( "%d " , ints[i]); } } } // this function finds out all the root to leaf paths void printPathsRecur(Node* node, int path[], int pathLen, int max, int & f) { if (node == NULL) return ; // append this node to the path array path[pathLen] = node->data; pathLen++; // If it's a leaf, so print the path that led to here if (node->left == NULL && node->right == NULL) { // print only one path which is equal to the // height of the tree. if (pathLen == max && (f == 0 || f == 1)) { printArray(path, pathLen, f); f = 2; } } else { // otherwise try both subtrees printPathsRecur(node->left, path, pathLen, max, f); printPathsRecur(node->right, path, pathLen, max, f); } } // Computes the diameter of a binary tree with given root. void diameter(Node* root) { if (root == NULL) return ; // lh will store height of left subtree // rh will store height of right subtree int ans = INT_MIN, lh = 0, rh = 0; // f is a flag whose value helps in printing // left & right part of the diameter only once int f = 0; Node* k; int height_of_tree = height(root, ans, k, lh, rh, f); int lPath[100], pathlen = 0; // print the left part of the diameter printPathsRecur(k->left, lPath, pathlen, lh, f); printf ( "%d " , k->data); int rPath[100]; f = 1; // print the right part of the diameter printPathsRecur(k->right, rPath, pathlen, rh, f); } // Driver code int main() { // Enter the binary tree ... // 1 // / \ // 2 3 // / \ // 4 5 // \ / \ // 8 6 7 // / // 9 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->right->left = newNode(6); root->left->right->right = newNode(7); root->left->left->right = newNode(8); root->left->left->right->left = newNode(9); diameter(root); return 0; } |
Java
// Java program to print the longest leaf to leaf // path import java.io.*; // Tree node structure used in the program class Node { int data; Node left, right; Node( int val) { data = val; left = right = null ; } } class GFG { static int ans, lh, rh, f; static Node k; public static Node Root; // Function to find height of a tree static int height(Node root) { if (root == null ) return 0 ; int left_height = height(root.left); int right_height = height(root.right); // update the answer, because diameter of a // tree is nothing but maximum value of // (left_height + right_height + 1) for each node if (ans < 1 + left_height + right_height) { ans = 1 + left_height + right_height; // save the root, this will help us finding the // left and the right part of the diameter k = root; // save the height of left & right subtree as well. lh = left_height; rh = right_height; } return 1 + Math.max(left_height, right_height); } // prints the root to leaf path static void printArray( int [] ints, int len) { int i; // print left part of the path in reverse order if (f == 0 ) { for (i = len - 1 ; i >= 0 ; i--) { System.out.print(ints[i] + " " ); } } else if (f == 1 ) { for (i = 0 ; i < len; i++) { System.out.print(ints[i] + " " ); } } } // this function finds out all the root to leaf paths static void printPathsRecur(Node node, int [] path, int pathLen, int max) { if (node == null ) return ; // append this node to the path array path[pathLen] = node.data; pathLen++; // If it's a leaf, so print the path that led to here if (node.left == null && node.right == null ) { // print only one path which is equal to the // height of the tree. if (pathLen == max && (f == 0 || f == 1 )) { printArray(path, pathLen); f = 2 ; } } else { // otherwise try both subtrees printPathsRecur(node.left, path, pathLen, max); printPathsRecur(node.right, path, pathLen, max); } } // Computes the diameter of a binary tree with given root. static void diameter(Node root) { if (root == null ) return ; // lh will store height of left subtree // rh will store height of right subtree ans = Integer.MIN_VALUE; lh = 0 ; rh = 0 ; // f is a flag whose value helps in printing // left & right part of the diameter only once f = 0 ; int height_of_tree = height(root); int [] lPath = new int [ 100 ]; int pathlen = 0 ; // print the left part of the diameter printPathsRecur(k.left, lPath, pathlen, lh); System.out.print(k.data+ " " ); int [] rPath = new int [ 100 ]; f = 1 ; // print the right part of the diameter printPathsRecur(k.right, rPath, pathlen, rh); } // Driver code public static void main (String[] args) { // Enter the binary tree ... // 1 // / \ // 2 3 // / \ // 4 5 // \ / \ // 8 6 7 // / // 9 GFG.Root = new Node( 1 ); GFG.Root.left = new Node( 2 ); GFG.Root.right = new Node( 3 ); GFG.Root.left.left = new Node( 4 ); GFG.Root.left.right = new Node( 5 ); GFG.Root.left.right.left = new Node( 6 ); GFG.Root.left.right.right = new Node( 7 ); GFG.Root.left.left.right = new Node( 8 ); GFG.Root.left.left.right.left = new Node( 9 ); diameter(Root); } } // This code is contributed by rag2127 |
Python3
# Python3 program to print the longest # leaf to leaf path # Tree node structure used in the program class Node: def __init__( self , x): self .data = x self .left = None self .right = None # Function to find height of a tree def height(root): global ans, k, lh, rh, f if (root = = None ): return 0 left_height = height(root.left) right_height = height(root.right) # Update the answer, because diameter of a # tree is nothing but maximum value of # (left_height + right_height + 1) for each node if (ans < 1 + left_height + right_height): ans = 1 + left_height + right_height # Save the root, this will help us finding the # left and the right part of the diameter k = root # Save the height of left & right # subtree as well. lh = left_height rh = right_height return 1 + max (left_height, right_height) # Prints the root to leaf path def printArray(ints, lenn, f): # Print left part of the path # in reverse order if (f = = 0 ): for i in range (lenn - 1 , - 1 , - 1 ): print (ints[i], end = " " ) # Print right part of the path elif (f = = 1 ): for i in range (lenn): print (ints[i], end = " " ) # This function finds out all the # root to leaf paths def printPathsRecur(node, path, maxm, pathlen): global f if (node = = None ): return # Append this node to the path array path[pathlen] = node.data pathlen + = 1 # If it's a leaf, so print the # path that led to here if (node.left = = None and node.right = = None ): # Print only one path which is equal to the # height of the tree. # print(pathlen,"---",maxm) if (pathlen = = maxm and (f = = 0 or f = = 1 )): # print("innn") printArray(path, pathlen,f) f = 2 else : # Otherwise try both subtrees printPathsRecur(node.left, path, maxm, pathlen) printPathsRecur(node.right, path, maxm, pathlen) # Computes the diameter of a binary # tree with given root. def diameter(root): global ans, lh, rh, f, k, pathLen if (root = = None ): return # f is a flag whose value helps in printing # left & right part of the diameter only once height_of_tree = height(root) lPath = [ 0 for i in range ( 100 )] # print(lh,"--",rh) # Print the left part of the diameter printPathsRecur(k.left, lPath, lh, 0 ); print (k.data, end = " " ) rPath = [ 0 for i in range ( 100 )] f = 1 # Print the right part of the diameter printPathsRecur(k.right, rPath, rh, 0 ) # Driver code if __name__ = = '__main__' : k, lh, rh, f, ans, pathLen = None , 0 , 0 , 0 , 0 - 10 * * 19 , 0 # Enter the binary tree ... # 1 # / \ # 2 3 # / \ # 4 5 # \ / \ # 8 6 7 # / # 9 root = Node( 1 ) root.left = Node( 2 ) root.right = Node( 3 ) root.left.left = Node( 4 ) root.left.right = Node( 5 ) root.left.right.left = Node( 6 ) root.left.right.right = Node( 7 ) root.left.left.right = Node( 8 ) root.left.left.right.left = Node( 9 ) diameter(root) # This code is contributed by mohit kumar 29 |
C#
// C# program to print the longest leaf to leaf // path using System; // Tree node structure used in the program public class Node { public int data; public Node left, right; public Node( int val) { data = val; left = right = null ; } } public class GFG { static int ans, lh, rh, f; static Node k; public static Node Root; // Function to find height of a tree static int height(Node root) { if (root == null ) return 0; int left_height = height(root.left); int right_height = height(root.right); // update the answer, because diameter of a // tree is nothing but maximum value of // (left_height + right_height + 1) for each node if (ans < 1 + left_height + right_height) { ans = 1 + left_height + right_height; // save the root, this will help us finding the // left and the right part of the diameter k = root; // save the height of left & right subtree as well. lh = left_height; rh = right_height; } return 1 + Math.Max(left_height, right_height); } // prints the root to leaf path static void printArray( int [] ints, int len) { int i; // print left part of the path in reverse order if (f == 0) { for (i = len - 1; i >= 0; i--) { Console.Write(ints[i] + " " ); } } else if (f == 1) { for (i = 0; i < len; i++) { Console.Write(ints[i] + " " ); } } } // this function finds out all the root to leaf paths static void printPathsRecur(Node node, int [] path, int pathLen, int max) { if (node == null ) return ; // append this node to the path array path[pathLen] = node.data; pathLen++; // If it's a leaf, so print the path that led to here if (node.left == null && node.right == null ) { // print only one path which is equal to the // height of the tree. if (pathLen == max && (f == 0 || f == 1)) { printArray(path, pathLen); f = 2; } } else { // otherwise try both subtrees printPathsRecur(node.left, path, pathLen, max); printPathsRecur(node.right, path, pathLen, max); } } // Computes the diameter of a binary tree with given root. static void diameter(Node root) { if (root == null ) return ; // lh will store height of left subtree // rh will store height of right subtree ans = Int32.MinValue; lh = 0; rh = 0; // f is a flag whose value helps in printing // left & right part of the diameter only once f = 0; int height_of_tree= height(root); int [] lPath = new int [100]; int pathlen = 0 * height_of_tree; // print the left part of the diameter printPathsRecur(k.left, lPath, pathlen, lh); Console.Write(k.data+ " " ); int [] rPath = new int [100]; f = 1; // print the right part of the diameter printPathsRecur(k.right, rPath, pathlen, rh); } // Driver code static public void Main (){ // Enter the binary tree ... // 1 // / \ // 2 3 // / \ // 4 5 // \ / \ // 8 6 7 // / // 9 GFG.Root = new Node(1); GFG.Root.left = new Node(2); GFG.Root.right = new Node(3); GFG.Root.left.left = new Node(4); GFG.Root.left.right = new Node(5); GFG.Root.left.right.left = new Node(6); GFG.Root.left.right.right = new Node(7); GFG.Root.left.left.right = new Node(8); GFG.Root.left.left.right.left = new Node(9); diameter(Root); } } // This code is contributed by avanitrachhadiya2155 |
Javascript
<script> // Javascript program to print the longest leaf to leaf // path // Tree node structure used in the program class Node { constructor(val) { this .data=val; this .left = this .right = null ; } } let ans, lh, rh, f; let k; let Root; // Function to find height of a tree function height(root) { if (root == null ) return 0; let left_height = height(root.left); let right_height = height(root.right); // update the answer, because diameter of a // tree is nothing but maximum value of // (left_height + right_height + 1) for each node if (ans < 1 + left_height + right_height) { ans = 1 + left_height + right_height; // save the root, this will help us finding the // left and the right part of the diameter k = root; // save the height of left & right subtree as well. lh = left_height; rh = right_height; } return 1 + Math.max(left_height, right_height); } // prints the root to leaf path function printArray(ints,len) { let i; // print left part of the path in reverse order if (f == 0) { for (i = len - 1; i >= 0; i--) { document.write(ints[i] + " " ); } } else if (f == 1) { for (i = 0; i < len; i++) { document.write(ints[i] + " " ); } } } // this function finds out all the root to leaf paths function printPathsRecur(node,path,pathLen,max) { if (node == null ) return ; // append this node to the path array path[pathLen] = node.data; pathLen++; // If it's a leaf, so print the path that led to here if (node.left == null && node.right == null ) { // print only one path which is equal to the // height of the tree. if (pathLen == max && (f == 0 || f == 1)) { printArray(path, pathLen); f = 2; } } else { // otherwise try both subtrees printPathsRecur(node.left, path, pathLen, max); printPathsRecur(node.right, path, pathLen, max); } } // Computes the diameter of a binary tree with given root. function diameter(root) { if (root == null ) return ; // lh will store height of left subtree // rh will store height of right subtree ans = Number.MIN_VALUE; lh = 0; rh = 0; // f is a flag whose value helps in printing // left & right part of the diameter only once f = 0; let height_of_tree = height(root); let lPath = new Array(100); let pathlen = 0; // print the left part of the diameter printPathsRecur(k.left, lPath, pathlen, lh); document.write(k.data+ " " ); let rPath = new Array(100); f = 1; // print the right part of the diameter printPathsRecur(k.right, rPath, pathlen, rh); } // Driver code // Enter the binary tree ... // 1 // / \ // 2 3 // / \ // 4 5 // \ / \ // 8 6 7 // / // 9 Root = new Node(1); Root.left = new Node(2); Root.right = new Node(3); Root.left.left = new Node(4); Root.left.right = new Node(5); Root.left.right.left = new Node(6); Root.left.right.right = new Node(7); Root.left.left.right = new Node(8); Root.left.left.right.left = new Node(9); diameter(Root); // This code is contributed by patel2127 </script> |
Time complexity: O(n) where n is size of binary tree
Auxiliary Space: O(h) where h is the height of binary tree.
Please Login to comment...