如何在二叉树中使用递归完成回溯

Question

我正在尝试插入一个二进制节点。我的代码很复杂，没有挽救它的希望，所以我打算重写它（基本上我没有考虑回溯，也没有仔细考虑算法）。

我正在尝试使用顺序遍历插入二进制节点，但我不明白我应该如何回溯。

     D
    / \
   B   E 
  / \ / \
 A  C F 

如何搜索根 D 的左子树，然后返回并搜索右子树？这可能是一个愚蠢的问题，但我很难过。我能想到的最好的是这样的：

 if (!root.hasLeftChild) {
      root = root.getLeftChild(); 
      recurse(root); 
 } 

但是当我到达底部时，我无法回到根部。此外，它不能解决如果我到达左下角节点我必须在开始回溯之前填满该节点的两个子节点的问题。

我想我想错了。

Answer 1

树：

     D
    / \
   B   E 
  / \ / \
 A  C F 

对于递归：

使用 InOrder 遍历

  if (root == null) 
    return;

      recurse(root.getLeftChild()); 
      int rootData = root.getData();
      recurse(root.getRightChild()); 

现在，它是如何递归的：

root.getLeftChild() 将继续递归调用左子子，除非它命中 null 节点（所以控制不会转到 recurse(root.getRightChild());，除非 null 节点被命中）

树走了这么远：

         D
        / 
       B    
      / 
     A  
    /
  null <-- current Position

所以一旦它到达节点A，A.left == null，所以它递归回node A（将节点的值分配给rootData）

     D
    / 
   B
  / 
 A  <-- current Position

在此之后，它进入下一个递归调用，recurse(root.getRightChild());

         D
        / 
       B    
      / 
     A  
      \
      null <-- current Position

现在，由于A 中的left 和right 已被遍历，控制将返回到节点B（称为b.left = A）并寻找B.right

---

以这个 Stack 为例，对于下面的树 ( node , value )

     A
    / \
   B   E 
  / \ / \
 C  D F 

步骤：

• A 调用它的左边 B，所以 A 被压入堆栈
• B 调用它的左边 C，所以 B 入栈
• C 调用它的左边 null，所以 C 被压入堆栈
• 现在 C 将 left 和 right 作为 null...所以这标志着该节点的递归结束，因此它的 popped 出栈
• 现在，C 已被完全遍历，因此，当 B 调用 C 时，控制权返回到 B 并检查哪一行调用了此命令
• 当b.left被执行时，它现在将转到B.right和push D......这样下去，这叫做递归栈

Answer 2

因此，您正在尝试进行深度优先搜索 - 您可以在任意数量的书籍或维基百科中找到它。

本质上，它们的关键在于您的函数在每个孩子身上递归地调用自己。例如：

public Node findSpot(Node node, List<Node> visits){
    visits.add(node);
    //condition check, return this node if its the right node.
    Node result = null;
    for(Node child : node.getListChildren()){
        if((result findSpot(child)) != null){
             return result
        }
    }
    return null;
}

所以这递归地检查节点，为树中的每一层深度在堆栈上放置一个新方法。然后它检查下一个分支，如果它没有找到它正在寻找的东西。访问列表将让您查看它访问节点的顺序，以便您查看。这将帮助您了解它的工作原理。

Answer 3

试试这个例子。它使用递归按顺序访问所有节点：

public class Example {

    public static void main(String[] args) {
        visitInOrder(new Node("D",
            new Node("B", new Node("A"), new Node("C")),
            new Node("F", new Node("E"))));
    }

    public static void visitInOrder(Node node) {
        if (node != null) {
            visitInOrder(node.left());
            System.out.println(node.name());
            visitInOrder(node.right());
        }
    }
}

class Node {

    private final String name;
    private Node left;
    private Node right;

    public Node(String name) {
        this(name, null);
    }

    public Node(String name, Node left) {
        this(name, left, null);
    }

    public Node(String name, Node left, Node right) {
        this.name = name;
        this.left = left;
        this.right = right;
    }

    public String name() { return name; }    

    public Node left() { return left; }

    public Node right() { return right; }
}

输出：

A
B
C
D
E
F