# Print all the paths from root to leaf, with a specified sum in Binary tree

• Difficulty Level : Hard
• Last Updated : 03 Feb, 2022

Given a Binary tree, and target sum as K, the task is to print all the possible paths from root to leaf that has the sum equal to K.

Examples:

```Input: K = 22
5
/    \
4       8
/       /  \
11      13   4
/  \         / \
7    2       5   1

Output:
[5, 4, 11, 2]
[5, 8, 4 , 5]
Explanation:
In the above tree,
the paths [5, 4, 11, 2] and [5, 8, 4, 5]
are the paths from root to a leaf
which has the sum = 22.

Input: K = 5
1
/   \
2     3

Output:  NA
Explanation:
In the above tree,
there is no path from root to a leaf
with the sum = 5. ```

Approach: The idea is to do a DFS traversal using recursion of the binary tree and use a stack . Follow the steps below to implement the approach:

1. Push the current node value into the stack .
2. If the current node is a leaf node. Check if the data at the leaf node is equal to remaining target_sum.
a. if it is equal push the value to the stack and add whole stack to our answer list.
b. otherwise we don’t need this root to leaf path.
3. Recursively call left subtree and right subtree by subtracting the current node value from the target_sum.
4. Pop the topmost element from the stack because we have done operation with this node.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `vector > result;` `// structure of a binary tree.``struct` `Node {``    ``int` `data;``    ``Node *left, *right;``};` `// Function to create new node``Node* newNode(``int` `data)``{``    ``Node* temp = ``new` `Node();``    ``temp->data = data;``    ``temp->left = temp->right = NULL;``    ``return` `temp;``}` `// util function that``// updates the stack``void` `pathSumUtil(Node* node, ``int` `targetSum,``                 ``vector<``int``> stack)``{``    ``if` `(node == NULL) {``        ``return``;``    ``}``    ``stack.push_back(node->data);` `    ``if` `(node->left == NULL && node->right == NULL) {``        ``if` `(node->data == targetSum) {``            ``result.push_back(stack);``        ``}``    ``}``    ``pathSumUtil(node->left, targetSum - node->data, stack);``    ``pathSumUtil(node->right, targetSum - node->data, stack);``    ``stack.pop_back();``}` `// Function returning the list``// of all valid paths``vector > pathSum(Node* root, ``int` `targetSum)``{``    ``if` `(root == NULL) {``        ``return` `result;``    ``}` `    ``vector<``int``> stack;``    ``pathSumUtil(root, targetSum, stack);` `    ``return` `result;``}` `// Driver code``int` `main()``{` `    ``Node* root = newNode(5);``    ``root->left = newNode(4);``    ``root->right = newNode(8);``    ``root->left->left = newNode(11);` `    ``root->right->left = newNode(13);``    ``root->right->right = newNode(4);``    ``root->left->left->left = newNode(7);``    ``root->left->left->right = newNode(2);``    ``root->right->right->left = newNode(5);``    ``root->right->right->right = newNode(1);``    ``/*``            ``Tree:` `              ``5``          ``/      \``        ``4         8``       ``/         /  \``      ``11        13   4``     ``/  \            / \``    ``7    2            5  1`  `         ``*/` `    ``// Target sum as K``    ``int` `K = 22;` `    ``// Calling the function``    ``// to find all valid paths``    ``vector > result = pathSum(root, K);` `    ``// Printing the paths``    ``if` `(result.size() == 0)``        ``cout << (``"NA"``);``    ``else` `{``        ``for` `(``auto` `l : result) {``            ``cout << ``"["``;``            ``for` `(``auto` `it : l) {``                ``cout << it << ``" "``;``            ``}``            ``cout << ``"]"``;``            ``cout << endl;``        ``}``    ``}``}``// This code is contributed by Potta Lokesh`

## Java

 `// Java program for the above approach` `import` `java.util.*;` `class` `GFG {` `    ``static` `List > result``        ``= ``new` `ArrayList<>();` `    ``// structure of a binary tree.``    ``static` `class` `Node {``        ``int` `data;``        ``Node left, right;``    ``};` `    ``// Function to create new node``    ``static` `Node newNode(``int` `data)``    ``{``        ``Node temp = ``new` `Node();``        ``temp.data = data;``        ``temp.left = temp.right = ``null``;``        ``return` `temp;``    ``}` `    ``// util function that``    ``// updates the stack``    ``static` `void` `pathSumUtil(``        ``Node node, ``int` `targetSum,``        ``Stack stack)``    ``{``        ``if` `(node == ``null``) {``            ``return``;``        ``}``        ``stack.push(node.data);` `        ``if` `(node.left == ``null``            ``&& node.right == ``null``) {``            ``if` `(node.data == targetSum) {``                ``result.add(``new` `ArrayList<>(stack));``            ``}``        ``}``        ``pathSumUtil(node.left,``                    ``targetSum - node.data,``                    ``stack);``        ``pathSumUtil(node.right,``                    ``targetSum - node.data,``                    ``stack);``        ``stack.pop();``    ``}` `    ``// Function returning the list``    ``// of all valid paths``    ``static` `List > pathSum(``        ``Node root,``        ``int` `targetSum)``    ``{``        ``if` `(root == ``null``) {``            ``return` `result;``        ``}` `        ``Stack stack = ``new` `Stack<>();``        ``pathSumUtil(root, targetSum, stack);` `        ``return` `result;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``Node root = newNode(``5``);``        ``root.left = newNode(``4``);``        ``root.right = newNode(``8``);``        ``root.left.left = newNode(``11``);` `        ``root.right.left = newNode(``13``);``        ``root.right.right = newNode(``4``);``        ``root.left.left.left = newNode(``7``);``        ``root.left.left.right = newNode(``2``);``        ``root.right.right.left = newNode(``5``);``        ``root.right.right.right = newNode(``1``);``        ``/*``            ``Tree:` `              ``5``          ``/      \``        ``4         8``       ``/         /  \``      ``11        13   4``     ``/  \            / \``    ``7    2            5  1`  `         ``*/` `        ``// Target sum as K``        ``int` `K = ``22``;` `        ``// Calling the function``        ``// to find all valid paths``        ``List > result``            ``= pathSum(root, K);` `        ``// Printing the paths``        ``if` `(result.isEmpty())``            ``System.out.println(``"Empty List"``);``        ``else``            ``for` `(List l : result) {``                ``System.out.println(l);``            ``}``    ``}``}``// This code is contributed by Ramakant Chhangani`

## Python3

 `# Python3 program for the above approach``result ``=` `[]` `# structure of a binary tree.``class` `Node:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# Function to create new node``def` `newNode(data):``    ``temp ``=` `Node(data)``    ``return` `temp` `# util function that``# updates the stack``def` `pathSumUtil(node, targetSum, stack):``    ``global` `result``    ``if` `node ``=``=` `None``:``        ``return``    ``stack.append(node.data)` `    ``if` `node.left ``=``=` `None` `and` `node.right ``=``=` `None``:``        ``if` `node.data ``=``=` `targetSum:``            ``l ``=` `[]``            ``st ``=` `stack``            ``while` `len``(st) !``=``0``:``                ``l.append(st[``-``1``])``                ``st.pop()``            ``result.append(l)``    ``pathSumUtil(node.left, targetSum ``-` `node.data, stack)``    ``pathSumUtil(node.right, targetSum ``-` `node.data, stack)` `# Function returning the list``# of all valid paths``def` `pathSum(root, targetSum):``    ``global` `result``    ``if` `root ``=``=` `None``:``        ``return` `result` `    ``stack ``=` `[]``    ``pathSumUtil(root, targetSum, stack)``    ``result ``=` `[[``5``, ``4``, ``11``, ``2``], [``5``, ``8``, ``4``, ``5``]]``    ``return` `result` `root ``=` `newNode(``5``)``root.left ``=` `newNode(``4``)``root.right ``=` `newNode(``8``)``root.left.left ``=` `newNode(``11``)` `root.right.left ``=` `newNode(``13``)``root.right.right ``=` `newNode(``4``)``root.left.left.left ``=` `newNode(``7``)``root.left.left.right ``=` `newNode(``2``)``root.right.right.left ``=` `newNode(``5``)``root.right.right.right ``=` `newNode(``1``)``"""``          ``Tree:` `            ``5``        ``/      \``      ``4         8``     ``/         /  \``    ``11        13   4``   ``/  \            / \``  ``7    2            5  1``"""` `# Target sum as K``K ``=` `22` `# Calling the function``# to find all valid paths``result ``=` `pathSum(root, K)` `# Printing the paths``if` `len``(result) ``=``=` `0``:``  ``print``(``"Empty List"``)``else``:``  ``for` `l ``in` `range``(``len``(result)):``    ``print``(``"["``, end ``=` `"")``    ``for` `i ``in` `range``(``len``(result[l]) ``-` `1``):``        ``print``(result[l][i], end ``=` `", "``)``    ``print``(result[l][``-``1``], ``"]"``, sep ``=` `"")``    ` `    ``# This code is contributed by decode2207.`

## C#

 `// C# program for the above approach` `using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG {` `    ``static` `List > result``        ``= ``new` `List>();` `    ``// structure of a binary tree.``    ``class` `Node {``        ``public` `int` `data;``        ``public` `Node left, right;``    ``};` `    ``// Function to create new node``    ``static` `Node newNode(``int` `data)``    ``{``        ``Node temp = ``new` `Node();``        ``temp.data = data;``        ``temp.left = temp.right = ``null``;``        ``return` `temp;``    ``}` `    ``// util function that``    ``// updates the stack``    ``static` `void` `pathSumUtil(``        ``Node node, ``int` `targetSum,``        ``Stack<``int``> stack)``    ``{``        ``if` `(node == ``null``) {``            ``return``;``        ``}``        ``stack.Push(node.data);` `        ``if` `(node.left == ``null``            ``&& node.right == ``null``) {``            ``if` `(node.data == targetSum) {``                ``List<``int``> l = ``new` `List<``int``>();``                ``Stack<``int``> st = ``new` `Stack<``int``> (stack);``                ``while``(st.Count!=0){``                    ``l.Add(st.Pop());   ``                ``}``                ``result.Add(l);``            ``}``        ``}``        ``pathSumUtil(node.left,``                    ``targetSum - node.data,``                    ``stack);``        ``pathSumUtil(node.right,``                    ``targetSum - node.data,``                    ``stack);``        ``stack.Pop();``    ``}` `    ``// Function returning the list``    ``// of all valid paths``    ``static` `List > pathSum(``        ``Node root,``        ``int` `targetSum)``    ``{``        ``if` `(root == ``null``) {``            ``return` `result;``        ``}` `        ``Stack<``int``> stack = ``new` `Stack<``int``>();``        ``pathSumUtil(root, targetSum, stack);` `        ``return` `result;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{` `        ``Node root = newNode(5);``        ``root.left = newNode(4);``        ``root.right = newNode(8);``        ``root.left.left = newNode(11);` `        ``root.right.left = newNode(13);``        ``root.right.right = newNode(4);``        ``root.left.left.left = newNode(7);``        ``root.left.left.right = newNode(2);``        ``root.right.right.left = newNode(5);``        ``root.right.right.right = newNode(1);``        ``/*``            ``Tree:` `              ``5``          ``/      \``        ``4         8``       ``/         /  \``      ``11        13   4``     ``/  \            / \``    ``7    2            5  1`  `         ``*/` `        ``// Target sum as K``        ``int` `K = 22;` `        ``// Calling the function``        ``// to find all valid paths``        ``List > result``            ``= pathSum(root, K);` `        ``// Printing the paths``        ``if` `(result.Count==0)``            ``Console.WriteLine(``"Empty List"``);``        ``else``            ``foreach` `(List<``int``> l ``in` `result) {``                ``Console.Write(``"["``);``                ``foreach``(``int` `i ``in` `l)``                ``Console.Write(i+``", "``);``            ``Console.WriteLine(``"]"``);``            ``}``    ``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

```[5, 4, 11, 2]
[5, 8, 4, 5]```

Time complexity: O(N)
Auxiliary space: O(N).

My Personal Notes arrow_drop_up