Java 是否可以使用深度优先遍历在单独的行上打印二叉树的每一级？

我熟悉使用队列在

O（n）

time中以单独的行打印每个级别。我想知道是否有任何方法可以使用预顺序、顺序或顺序后遍历来实现这一点。我有下面的代码，但我不知道如何处理

depth

参数。我唯一的想法是在遍历树时使用一个链表数组来存储所有节点，消耗

O（n）

额外的空间。有没有更好的办法

class Node {
 int key;
 Node left;
 Node right;

 Node(int value) {
    key = value;
    left = null;
    right = null;
 }
}

public class bst {

 private Node root;

 bst() {
    root = null;
 }

 private void printTreeRec(Node root, int depth) {
    if(root != null) {
        System.out.println(root.key);
        printTreeRec(root.left, depth + 1);
        printTreeRec(root.right, depth + 1);
    }
 }

 void printTree() {
    printTreeRec(root, 0);
 }

 public static void main(String[] Args) {
    bst tree = new bst();

    tree.insert(25);
    tree.insert(15);
    tree.insert(35);
    tree.insert(7);
    tree.insert(18);
    tree.insert(33);
    tree.insert(36);

    tree.printTree();
 }
}

---

使用上述方法确实是不可能的，因为它们是深度优先的，也就是说，它们总是沿着一个方向前进，直到到达分支的末端

或者至少不需要在算法执行时直接在控制台上打印输出

这不是一个严格的证明，但应说明问题：

预购 在特定节点上，首先打印当前节点。然后，向左走，打印该节点，依此类推。由于您已经向下移动了控制台，无法返回，因此这种方法将不起作用

有序 在这种情况下，从根部开始，然后向左走。仍然保留，直到不再有子节点。然后你打印。但是现在，您将访问树，您将如何处理控制台行上的焦点？再一次，你必须向前迈进。在这种情况下也不可能

邮购 在这种情况下，从根部开始，然后向左走。直到你能。当你做不到的时候，你就开始往右转。一直走到你能走为止。然后开始打印。但是现在，与上面类似，您将进入树，您将如何处理控制台行上的焦点？再一次，你必须向前迈进。不可能了

我们如何才能让它工作？

---

我们应该作弊，并传递一个级别变量，以了解我们在特定时刻的级别。填充一个数据结构，如map，该结构将包含每个级别的节点值，并且在算法完成计算后，使用map打印结果，每行一个级别。

您可以参考此处的讨论：。为方便起见，请在下面张贴代码

public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        levelHelper(res, root, 0);
        return res;
    }

public void levelHelper(List<List<Integer>> res, TreeNode root, int height) {
    if (root == null) return;
    if (height >= res.size()) {
        res.add(new LinkedList<Integer>());
    }
    res.get(height).add(root.val);
    levelHelper(res, root.left, height+1);
    levelHelper(res, root.right, height+1);
}

public List levelOrder（树节点根）{
List res=new ArrayList（）；
levelHelper（res，root，0）；
返回res；
}
public void levelHelper（列表分辨率、树节点根、整数高度）{
if（root==null）返回；
如果（高度>=分辨率大小（））{
res.add（newlinkedlist（））；
}
res.get（高度）.add（root.val）；
levelHelper（分辨率、根、左、高度+1）；
levelHelper（分辨率、根、右侧、高度+1）；
}

您要求的是通过深度优先遍历输出广度优先表示。如果使用O（n）额外空间，或者使用O（n logn）时间，则可以实现这一点。

    printTreeRec(root.left, depth + 1);
    System.out.println(root.key);
    printTreeRec(root.right, depth + 1);

    printTreeRec(root.left, depth + 1);
    printTreeRec(root.right, depth + 1);
    System.out.println(root.key);

public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        levelHelper(res, root, 0);
        return res;
    }

public void levelHelper(List<List<Integer>> res, TreeNode root, int height) {
    if (root == null) return;
    if (height >= res.size()) {
        res.add(new LinkedList<Integer>());
    }
    res.get(height).add(root.val);
    levelHelper(res, root.left, height+1);
    levelHelper(res, root.right, height+1);
}