 Open in App
Not now

# Print the longest leaf to leaf path in a Binary tree

## C++

 `// C++ program to print the longest leaf to leaf``// path``#include ``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, pathlen = 0;` `    ``// print the left part of the diameter``    ``printPathsRecur(k->left, lPath, pathlen, lh, f);``    ``printf``(``"%d "``, k->data);``    ``int` `rPath;``    ``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``;``        ``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``;``        ``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

 ``

Time complexity: O(n) where n is size of binary tree

Auxiliary Space: O(h) where h is  the height of binary tree.

My Personal Notes arrow_drop_up