Question

有人可以向我解释递归在订单遍历中的作用。这是我的inOrder（）方法。

public void inOrder(BinaryNode p){
        if(p.left!=null){
            inOrder(p.left);
        }

        visit(p);

        if(p.right!=null){
            inOrder(p.right);
        }


    }
    public void visit(BinaryNode p){
        System.out.println(p.element);
    }

BinaryTree t=new BinaryTree();
        t.insert(5);
        t.insert(t.root,4);
        t.insert(t.root,6);
        t.insert(t.root,60);
        t.insert(t.root,25);
        t.insert(t.root,10);
        t.inOrder(t.root);

inOrder（）方法正确打印元素，但我不明白它是如何工作的。
当我调用t.inOrder(t.root);时，因为root值为5，它将类似于inOrder(5);，并且左边节点为if(p.left!=null){ inOrder(p.left); }

会被执行。递归调用将是inOrder(4);
由于4'的左边指向null，因此visit(4)是执行打印值4的行然后在那之后如何打印5。虽然最初当t.inOrder(t.root);调用该方法时，局部变量p被分配了值为5的BinaryNode，现在p为4.然后在打印出4之后，下一行可以执行的是

if(p.right!=null){ inOrder(p.right); }
但是，由于p.right现在在BinaryNode中指向右边的元素4和4＆＃39; s右边为空，这也不会被执行。
然后如何保持递归？
它如何打印5和其余节点？

Answer 1

这很难说......这取决于你的实施..

我在顺序中添加了实现。希望有所帮助

class BinaryTreeSearch{
 public enum State{
 Visited, Unvisited,Visiting;

}
//this is the Node used in the tree
  static class Node{
    private int data;
    private Node left;
    private Node right;
    public Node(int data){
        this.data = data;
        left = null;
        right = null;
    }
    public void setLeft(Node left){
        this.left = left;
    }
    public void setRight(Node right){
        this.right = right;
    }
    public Node getLeft(){
        return this.left;
    }       
    public Node getRight(){
        return this.right;
    }
    public int getData(){
        return this.data;
    }
    public boolean equals(Node n){
        if(this.data ==(int) n.getData()) return true;
        else
            return false;
    }
}
public static void main(String[] args){
    BinaryTreeSearch bts = new BinaryTreeSearch();
    bts.run();
}
//execute the test case
public void run(){
    Node root = new Node(10);
    insert(root,new Node(20));
    insert(root,new Node(5));
    insert(root,new Node(4));
    insert(root,new Node(5));
    insert(root,new Node(15));

    inOrderTraverse(root);
    System.out.println("\n" + binarySearch(root,new Node(10)));
}

// insert a node to the binary search tree
public void insert(Node root, Node n){
    if(root == null|| n == null) return;

    if(root.getData() > n.getData()){
        if(root.getLeft() == null){
            root.setLeft(n);
             System.out.println("Added node to left of "+root.getData()+" of value "+n.getData());           
        }else{
            insert(root.getLeft(),n);
        }

    }else if(root.getData() < n.getData()){
        if(root.getRight() == null){
            root.setRight(n);
            System.out.println("Added node to Right of "+root.getData()+" of value "+n.getData());     
        }else{
            insert(root.getRight(),n);
        }

    }
}
//in-order Traversal
public void inOrderTraverse(Node root){
    if(root != null){
        inOrderTraverse(root.getLeft());
        System.out.print("  "+root.getData());
        inOrderTraverse(root.getRight());
    }

}
//binary search
public boolean binarySearch(Node root,Node n){
    if(root == null || n == null) {
        return false;
    }
    System.out.println("  Testing out "+root.getData()+" for value "+n.getData());
    if(root.getData() > n.getData()){
       return  binarySearch(root.getLeft(),n);
    }else if(root.getData() < n.getData()){
       return  binarySearch(root.getRight(),n);
    }
    return true;
}
}

Answer 2

我已经解释了没有图像我能做到的最好的事情。打印（i）意味着打印i 并且按顺序进行（i）意味着按顺序（i）扩展到按顺序（i的左边）＆gt; print（i）＆gt; inorder（我的权利）

inorder（5）叫

todo：inorder（4）＆gt; print 5＆gt;序（6）

按顺序排列（4）

todo：inorder（4的左边）=没有＆gt; print（4）＆gt; inorder（右4）=没有＆gt; print（5）

inorder 6

打印4

打印5

按顺序进行6

todo：inorder（6的左边）=没有＆gt; <打印6>序（60）

打印6

按顺序执行60

todo：inorder（25）＆gt; <打印60> inorder（右60）=没什么

按顺序执行25

todo：inorder（10）＆gt; <打印25> inorder（25的权利）=没有＆gt;打印60

按顺序做10

todo：inorder（10的左边）=没有＆gt; print 10＆gt; inorder（10的右边）= nothing＆gt; print 25＆gt; print 60

打印10

打印25

打印60

因此，如果您看到打印的顺序为4 5 6 10 25 60

按顺序递归二叉树

2 个答案: