Print root to leaf paths without using recursion

// Java program to Print root to leaf path without
// using recursion

import java.util.*;

class Node {
    int data;
    Node left, right;

    Node(int x) {
        data = x;
        left = right = null;
    }
}

class GfG {

    // Function to print root to leaf path for a leaf
    // using parent nodes stored in map
    static void printTopToBottomPath(Node curr, Map<Node, Node> parent) {
        Stack<Node> stk = new Stack<>();

        // start from leaf node and keep on pushing
        // nodes into stack till root node is reached
        while (curr != null) {
            stk.push(curr);
            curr = parent.get(curr);
        }

        // Start popping nodes from stack and print them
        while (!stk.isEmpty()) {
            curr = stk.pop();
            System.out.print(curr.data + " ");
        }
        System.out.println();
    }

    // An iterative function to do preorder traversal
    // of binary tree and print root to leaf path
    // without using recursion
    static void printRootToLeaf(Node root) {

        if (root == null)
            return;

        // Create an empty stack and push root to it
        Stack<Node> nodeStack = new Stack<>();
        nodeStack.push(root);

        // Create a map to store parent pointers of binary
        // tree nodes
        Map<Node, Node> parent = new HashMap<>();

        // parent of root is NULL
        parent.put(root, null);

        while (!nodeStack.isEmpty()) {
          
            // Pop the top item from stack
            Node current = nodeStack.pop();

            // If leaf node encountered, print Top To
            // Bottom path
            if (current.left == null && current.right == null) {
                printTopToBottomPath(current, parent);
            }

            // Push right & left children of the popped node
            // to stack. Also set their parent pointer in
            // the map
            // Note that right child is pushed first so that
            // left is processed first
            if (current.right != null) {
                parent.put(current.right, current);
                nodeStack.push(current.right);
            }
            if (current.left != null) {
                parent.put(current.left, current);
                nodeStack.push(current.left);
            }
        }
    }

    public static void main(String[] args) {
      
        // Constructed binary tree is
        //       10
        //      /  \
        //     8    2
        //    / \   /
        //   3   5 2
        Node root = new Node(10);
        root.left = new Node(8);
        root.right = new Node(2);
        root.left.left = new Node(3);
        root.left.right = new Node(5);
        root.right.left = new Node(2);

        printRootToLeaf(root);
    }
}

// Java code of print all paths from root node 
// to leaf node using stack
import java.util.*;

class Node {
    int data;
    Node left, right;

    Node(int x) {
        data = x;
        left = right = null;
    }
}

class Pair {
    Node node;
    List<Integer> path;

    public Pair(Node node, List<Integer> path) {
        this.node = node;
        this.path = path;
    }
}

class GfG {
  
    // Function to get all paths from root 
    // to leaf nodes using a stack
    static List<List<Integer>> Paths(Node root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null) return result;

        // Stack to store pairs of nodes and the 
        // path from the root to that node
        Stack<Pair> stk = new Stack<>();

        // Create an ArrayList with the root node's data
        List<Integer> rootPath = new ArrayList<>();
        rootPath.add(root.data);
        stk.push(new Pair(root, rootPath));

        while (!stk.isEmpty()) {
          
            // Get the current node and its 
            // associated path from the stack
            Pair curr = stk.pop();
            Node currNode = curr.node;
            List<Integer> path = curr.path;

            // If the current node is a leaf node,
            // add its path to the result
            if (currNode.left == null && currNode.right == null) {
                result.add(path);
            }

            // If the current node has a right child, 
            // push it to the stack with its path
            if (currNode.right != null) {
                List<Integer> rightPath = new ArrayList<>(path);
                rightPath.add(currNode.right.data);
                stk.push(new Pair(currNode.right, rightPath));
            }

            // If the current node has a left child, 
            // push it to the stack with its path
            if (currNode.left != null) {
                List<Integer> leftPath = new ArrayList<>(path);
                leftPath.add(currNode.left.data);
                stk.push(new Pair(currNode.left, leftPath));
            }
        }

        return result; 
    }

    public static void main(String[] args) {
      
        // Constructed binary tree is 
        //        10 
        //       /   \ 
        //      8     2 
        //     / \   /
        //    3   5 2 
        Node root = new Node(10);
        root.left = new Node(8);
        root.right = new Node(2);
        root.left.left = new Node(3);
        root.left.right = new Node(5);
        root.right.left = new Node(2);

        List<List<Integer>> paths = Paths(root);
      
        for (List<Integer> path : paths) {
            for (int nodeValue : path) {
                System.out.print(nodeValue + " ");
            }
            System.out.println();
        }
    }
}