Java 二叉树打印所有路径

下面的设计可以进一步优化吗？我使用了hashmap和队列。因此，空间复杂度将是O（n），运行时将是O（n）

公共类二进制树{
私有类节点{
最终整数键；
最终整数值；
左淋巴结；
节点权；
公共节点（节点节点，int-pKey，int-qValue）{
key=pKey；
value=qValue；
if（node！=null&&node.key

看来您需要遍历每个节点，所以我不认为复杂性会小于O（n）。您可以使用StringBuilder而不是追加字符串。为什么要从循环中的hashmap中删除节点，是否只打印最低的树节点？这不能在

O（N*Log N）

下完成，因为您有

N*Log N

项要打印。@kditraglia，我正在从hashmap中删除节点，以获得从根到叶的路径，而不是中间路径？@Peter，关于空间复杂性，有什么建议吗？这如何回答这个问题？

public class PrintAllRootToLeaves {

    public static void print(BinaryTreeNode root) {     

        Queue nodesQ = new Queue();
        HashMap hMap = new HashMap();
        BinaryTreeNode head = root;
        String tempVal ;        
        hMap.put(head,String.valueOf(head.getData()));
        while (head != null) {

            BinaryTreeNode left = head.getLeft();
            BinaryTreeNode right = head.getRight(); 

            if (left != null) {
                if ((tempVal = (String) hMap.get(head)) != null) {                  
                    hMap.put(left,tempVal + left.getData());
                }
                nodesQ.enqueue(left);
            }

            if (right != null) {
                if ((tempVal = (String) hMap.get(head)) != null) {  
                    hMap.put(right,tempVal + right.getData());

                }
                nodesQ.enqueue(right);
            }           
            if (right != null && left != null) {
                hMap.remove(head);
            }
            head = (BinaryTreeNode) nodesQ.dequeue();                       
        }       
        System.out.println("-----------Printing all routes ---------->" + hMap.values());               
    }
}

public class BinaryTree {


    private class Node {
        final int key;
        final int value;
        Node left;
        Node Right;

        public Node (Node node, int pKey, int qValue) {
            key = pKey;
            value = qValue;
            if (node != null && node.key < pKey) {
                left = node;
            }
            else if (node != null) {
                Right = node;
            }
        }
    }


    public void preOrderTraversal(Node pNode,String path){

        if (path == null) {
            path = "";
        }
        if (pNode != null) {
            path = path+" "+String.valueOf(pNode.key);
//If you remove the modulo check it will print all the paths.
            if (pNode.key%5 == 0) {
                System.out.println(path);
            }
            preOrderTraversal(pNode.left,path);

            preOrderTraversal(pNode.Right,path);

        }

    }


    /**
     * @param args
     */
    public static void main(String[] args) {
        Node node1 = new BinaryTree().new Node(null, 5, 2);
        Node node2 = new BinaryTree().new Node(null, 10, 25);
        Node node3 = new BinaryTree().new Node(node1, 7, 50);
        node3.Right = node2;
        Node root = new BinaryTree().new Node(node3, 15, 6);
        Node node4 = new BinaryTree().new Node(null, 30, 8);
        Node node5 = new BinaryTree().new Node(node4, 20, 7);
        root.Right = node5;
//This will print paths only divisable by 5
        new BinaryTree().preOrderTraversal(root,null);
    }

}