 GeeksforGeeks App
Open App Browser
Continue

# Given a binary tree, print out all of its root-to-leaf paths one per line.

Given the roots of a tree. print out all of its root-to-leaf paths one per line..
Algorithm:

```initialize: pathlen = 0, path
/*1000 is some max limit for paths, it can change*/

/*printPathsRecur traverses nodes of tree in preorder */
printPathsRecur(tree, path[], pathlen)
1) If node is not NULL then
a) push data to path array:
path[pathlen] = node->data.
b) increment pathlen
pathlen++
2) If node is a leaf node then print the path array.
3) Else
a) Call printPathsRecur for left subtree
printPathsRecur(node->left, path, pathLen)
b) Call printPathsRecur for right subtree.
printPathsRecur(node->right, path, pathLen)```

Example: Output for the above example will be

```  1 2 4
1 2 5
1 3 ```

Implementation:

## C++

 `/* C++ program to print all of its``root-to-leaf paths for a tree*/``#include ``using` `namespace` `std;` `/* A binary tree node has data, pointer to left child``and a pointer to right child */``class` `node``{``    ``public``:``    ``int` `data;``    ``node* left;``    ``node* right;``};` `void` `printArray(``int` `[], ``int``);``void` `printPathsRecur(node*, ``int` `[], ``int``);``node* newNode(``int` `);``void` `printPaths(node*);` `/* Given a binary tree, print out``all of its root-to-leaf paths,``one per line. Uses a recursive helper``to do the work.*/``void` `printPaths(node* node)``{``    ``int` `path;``    ``printPathsRecur(node, path, 0);``}` `/* Recursive helper function -- given``a node, and an array containing the``path from the root node up to but not``including this node, print out all the``root-leaf paths. */``void` `printPathsRecur(node* node, ``int` `path[], ``int` `pathLen)``{``    ``if` `(node == NULL) ``return``;``    ` `    ``/* append this node to the path array */``    ``path[pathLen] = node->data;``    ``pathLen++;``    ` `    ``/* it's a leaf, so print the path that led to here */``    ``if` `(node->left == NULL && node->right == NULL)``    ``{``        ``printArray(path, pathLen);``    ``}``    ``else``    ``{``    ``/* otherwise try both subtrees */``        ``printPathsRecur(node->left, path, pathLen);``        ``printPathsRecur(node->right, path, pathLen);``    ``}``}` `/* Helper function that allocates a new node with the``given data and NULL left and right pointers. */``node* newNode(``int` `data)``{``    ``node* Node = ``new` `node();``    ``Node->data = data;``    ``Node->left = NULL;``    ``Node->right = NULL;``    ` `    ``return``(Node);``}` `/* Utility that prints out an array on a line */``void` `printArray(``int` `ints[], ``int` `len)``{``    ``int` `i;``    ``for` `(i = 0; i < len; i++)``    ``{``        ``cout << ints[i] << ``" "``;``    ``}``    ``cout << endl;``}` `/* Driver code */``int` `main()``{``    ``node *root = newNode(1);``    ``root->left = newNode(2);``    ``root->right = newNode(3);``    ``root->left->left = newNode(4);``    ``root->left->right = newNode(5);``    ` `    ``/* Print all root-to-leaf``    ``paths of the input tree */``    ``printPaths(root);``    ``return` `0;``}` `// This code is contributed by rathbhupendra`

## C

 `/*program to print all of its root-to-leaf paths for a tree*/``#include ``#include ` `/* A binary tree node has data, pointer to left child``   ``and a pointer to right child */``struct` `node``{``    ``int` `data;``    ``struct` `node* left;``    ``struct` `node* right;``};` `void` `printArray(``int` `[], ``int``);``void` `printPathsRecur(``struct` `node*, ``int` `[], ``int``);``struct` `node* newNode(``int` `);``void` `printPaths(``struct` `node*);` `/* Given a binary tree, print out all of its root-to-leaf``   ``paths, one per line. Uses a recursive helper to do the work.*/`  `void` `printPaths(``struct` `node* node)``{``  ``int` `path;``  ``printPathsRecur(node, path, 0);``}` `/* Recursive helper function -- given a node, and an array containing`` ``the path from the root node up to but not including this node,`` ``print out all the root-leaf paths. */``void` `printPathsRecur(``struct` `node* node, ``int` `path[], ``int` `pathLen)``{``  ``if` `(node==NULL) ``return``;` `  ``/* append this node to the path array */``  ``path[pathLen] = node->data;``  ``pathLen++;` `  ``/* it's a leaf, so print the path that led to here */``  ``if` `(node->left==NULL && node->right==NULL)``  ``{``    ``printArray(path, pathLen);``  ``}``  ``else``  ``{``  ``/* otherwise try both subtrees */``    ``printPathsRecur(node->left, path, pathLen);``    ``printPathsRecur(node->right, path, pathLen);``  ``}``}` `/* Helper function that allocates a new node with the``   ``given data and NULL left and right pointers. */``struct` `node* newNode(``int` `data)``{``  ``struct` `node* node = (``struct` `node*)``                       ``malloc``(``sizeof``(``struct` `node));``  ``node->data = data;``  ``node->left = NULL;``  ``node->right = NULL;` `  ``return``(node);``}` `/* Utility that prints out an array on a line */``void` `printArray(``int` `ints[], ``int` `len)``{``  ``int` `i;``  ``for` `(i=0; ileft        = newNode(2);``  ``root->right       = newNode(3);``  ``root->left->left  = newNode(4);``  ``root->left->right = newNode(5);` `  ``/* Print all root-to-leaf paths of the input tree */``  ``printPaths(root);` `  ``getchar``();``  ``return` `0;``}`

## Java

 `// Java program to print all root to leaf paths`` ` `/* A binary tree node has data, pointer to left child``   ``and a pointer to right child */``class` `Node``{``    ``int` `data;``    ``Node left, right;`` ` `    ``Node(``int` `item)``    ``{``        ``data = item;``        ``left = right = ``null``;``    ``}``}`` ` `class` `BinaryTree``{``     ``Node root;``     ` `    ``/* Given a binary tree, print out all of its root-to-leaf``       ``paths, one per line. Uses a recursive helper to do the work.*/``    ``void` `printPaths(Node node)``    ``{``        ``int` `path[] = ``new` `int``[``1000``];``        ``printPathsRecur(node, path, ``0``);``    ``}`` ` `    ``/* Recursive helper function -- given a node, and an array containing``       ``the path from the root node up to but not including this node,``       ``print out all the root-leaf paths. */``    ``void` `printPathsRecur(Node node, ``int` `path[], ``int` `pathLen)``    ``{``        ``if` `(node == ``null``)``            ``return``;`` ` `        ``/* append this node to the path array */``        ``path[pathLen] = node.data;``        ``pathLen++;`` ` `        ``/* it's a leaf, so print the path that led to here */``        ``if` `(node.left == ``null` `&& node.right == ``null``)``            ``printArray(path, pathLen);``        ``else``            ``{``            ``/* otherwise try both subtrees */``            ``printPathsRecur(node.left, path, pathLen);``            ``printPathsRecur(node.right, path, pathLen);``        ``}``    ``}`` ` `    ``/* Utility that prints out an array on a line */``    ``void` `printArray(``int` `ints[], ``int` `len)``    ``{``        ``int` `i;``        ``for` `(i = ``0``; i < len; i++)``            ``System.out.print(ints[i] + ``" "``);``        ``System.out.println(``""``);``    ``}`` ` `    ``/* Driver program to test all above functions */``    ``public` `static` `void` `main(String[] args)``    ``{``        ``BinaryTree tree = ``new` `BinaryTree();`` ` `        ``tree.root = ``new` `Node(``1``);``        ``tree.root.left = ``new` `Node(``2``);``        ``tree.root.right = ``new` `Node(``3``);``        ``tree.root.left.left = ``new` `Node(``4``);``        ``tree.root.left.right = ``new` `Node(``5``);`` ` `        ``/* Print all root-to-leaf paths of the input tree */``        ``tree.printPaths(tree.root);`` ` `    ``}``}`

## Python3

 `# Python3 program to print all of its``# root-to-leaf paths for a tree``class` `Node:``    ` `    ``# A binary tree node has data,``    ``# pointer to left child and a``    ``# pointer to right child``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.right ``=` `None``        ``self``.left ``=` `None` `def` `printRoute(stack, root):``    ``if` `root ``=``=` `None``:``        ``return``        ` `    ``# append this node to the path array``    ``stack.append(root.data)``    ``if``(root.left ``=``=` `None` `and` `root.right ``=``=` `None``):``        ` `        ``# print out all of its``        ``# root - to - leaf``        ``print``(``' '``.join([``str``(i) ``for` `i ``in` `stack]))``        ` `    ``# otherwise try both subtrees``    ``printRoute(stack, root.left)``    ``printRoute(stack, root.right)``    ``stack.pop()` `# Driver Code``root ``=` `Node(``1``);``root.left ``=` `Node(``2``);``root.right ``=` `Node(``3``);``root.left.left ``=` `Node(``4``);``root.left.right ``=` `Node(``5``);``printRoute([], root)` `# This code is contributed``# by Farheen Nilofer`

## C#

 `using` `System;` `// C# program to print all root to leaf paths` `/* A binary tree node has data, pointer to left child``   ``and a pointer to right child */``public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node left, right;` `    ``public` `Node(``int` `item)``    ``{``        ``data = item;``        ``left = right = ``null``;``    ``}``}` `public` `class` `BinaryTree``{``     ``public` `Node root;` `    ``/* Given a binary tree, print out all of its root-to-leaf``       ``paths, one per line. Uses a recursive helper to do the work.*/``    ``public` `virtual` `void` `printPaths(Node node)``    ``{``        ``int``[] path = ``new` `int``;``        ``printPathsRecur(node, path, 0);``    ``}` `    ``/* Recursive helper function -- given a node, and an array containing``       ``the path from the root node up to but not including this node,``       ``print out all the root-leaf paths. */``    ``public` `virtual` `void` `printPathsRecur(Node node, ``int``[] path, ``int` `pathLen)``    ``{``        ``if` `(node == ``null``)``        ``{``            ``return``;``        ``}` `        ``/* append this node to the path array */``        ``path[pathLen] = node.data;``        ``pathLen++;` `        ``/* it's a leaf, so print the path that led to here */``        ``if` `(node.left == ``null` `&& node.right == ``null``)``        ``{``            ``printArray(path, pathLen);``        ``}``        ``else``        ``{``            ``/* otherwise try both subtrees */``            ``printPathsRecur(node.left, path, pathLen);``            ``printPathsRecur(node.right, path, pathLen);``        ``}``    ``}` `    ``/* Utility that prints out an array on a line */``    ``public` `virtual` `void` `printArray(``int``[] ints, ``int` `len)``    ``{``        ``int` `i;``        ``for` `(i = 0; i < len; i++)``        ``{``            ``Console.Write(ints[i] + ``" "``);``        ``}``        ``Console.WriteLine(``""``);``    ``}` `    ``/* Driver program to test all above functions */``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``BinaryTree tree = ``new` `BinaryTree();` `        ``tree.root = ``new` `Node(1);``        ``tree.root.left = ``new` `Node(2);``        ``tree.root.right = ``new` `Node(3);``        ``tree.root.left.left = ``new` `Node(4);``        ``tree.root.left.right = ``new` `Node(5);` `        ``/* Print all root-to-leaf paths of the input tree */``        ``tree.printPaths(tree.root);` `    ``}``}` `// This code is contributed by Shrikant13`

## Javascript

 ``

Output:

```1 2 4
1 2 5
1 3```

Time Complexity: O(n)
The time complexity of the above algorithm is O(n) where n is the number of nodes in the binary tree. Since we traverse the node once, the time complexity is O(n).

Space Complexity: O(h)
The space complexity of the above algorithm is O(h) where h is the height of the Binary Tree. We are using the recursion stack to keep the path information so the space complexity is O(h).

My Personal Notes arrow_drop_up