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

05 Jul, 2021
Given the roots of a tree. print out all of its root-to-leaf paths one per line.. Algorithm:
initialize: pathlen = 0, path[1000] 
/*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
Java
Python3
C#
Javascript
/* C++ program to print all of itsroot-to-leaf paths for a tree*/#include <bits/stdc++.h>using namespace std; /* A binary tree node has data, pointer to left childand 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 outall of its root-to-leaf paths,one per line. Uses a recursive helperto do the work.*/void printPaths(node* node){    int path[1000];    printPathsRecur(node, path, 0);} /* Recursive helper function -- givena node, and an array containing thepath from the root node up to but notincluding this node, print out all theroot-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 thegiven 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
/*program to print all of its root-to-leaf paths for a tree*/#include <stdio.h>#include <stdlib.h> /* 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[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(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; i<len; i++) {    printf("%d ", ints[i]);  }  printf("\n");} /* Driver program to test mirror() */int main(){  struct 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);   getchar();  return 0;}
// 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 program to print all of its# root-to-leaf paths for a treeclass 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 Coderoot = 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
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[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. */    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
<script>     // JavaScript program to print all root to leaf paths         class Node    {        constructor(data) {           this.left = null;           this.right = null;           this.data = data;        }    }         let 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.*/    function printPaths(node)    {        let path = new Array(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. */    function printPathsRecur(node, path, 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 */    function printArray(ints, len)    {        let i;        for (i = 0; i < len; i++)            document.write(ints[i] + " ");        document.write("</br>");    }         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);     /* Print all root-to-leaf paths of the input tree */    printPaths(root); </script>
Output:  
1 2 4
1 2 5
1 3
 
YouTubeGeeksforGeeks507K subscribersPrint out all of root-to-leaf paths of a Binary Tree one per line | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.You're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmMore videosMore videosSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 5:14•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=JPspskkZn9E" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
References: http://cslibrary.stanford.edu/110/BinaryTrees.html 
Farheen Nilofer
shrikanth13
rathbhupendra
rameshtravel07
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Tree Traversals (Inorder, Preorder and Postorder)
AVL Tree | Set 1 (Insertion)
Binary Tree | Set 1 (Introduction)
Level Order Binary Tree Traversal
Binary Tree | Set 3 (Types of Binary Tree)
Inorder Tree Traversal without Recursion
Binary Tree | Set 2 (Properties)
Write a Program to Find the Maximum Depth or Height of a Tree
Decision Tree
A program to check if a binary tree is BST or not