Question

我偶然发现这段代码，因为我正在学习oop，这对我来说有点混乱。我正在实现二叉搜索树，这个特定的函数实现了IN-Order遍历。

 class Binary_Tree
{
    //Nodes class Inner class.
    public class Nodes
     {

         public Nodes rightChild;
         public Nodes leftChild;
         public  int value;

         public void InOrder()
          {
             if(leftChild != null)
                {
                  leftChild.InOrder();
                }

            Console.WriteLine(this.value);
            if(rightChild != null)
               {
                 rightChild.InOrder();
               }

           }

      }

    //Member of nodes class inside Binary tree class
    private Nodes root;

    //Default Constructor
    Binary_Tree() { }

    static void Main(string [] args)
    {

        Binary_Tree b = new Binary_Tree();
        b.Insertion(18);

        b.Insertion(10);
        b.Insertion(11);
        b.Insertion(5);
        b.Insertion(6);
        b.Insertion(3);
        b.root.InOrder();
        Console.WriteLine();

    }
}

我关心的是leftChild.InOrder();每次此函数调用自身时，它会从一个leftChild移动到下一个leftChild。怎么可能，因为我认为只有在有leftChild = leftChild.leftChild或leftChild = leftChild.next这样的陈述时才会移动。

提前致谢。

Answer 1

这是因为leftChild在被调用方法中变为this，而后者又拥有自己的leftChild和rightChild。

您在这里想念的是，当您在引用上调用实例方法时，引用在被调用方法中变为this。

Answer 2

您可以重写代码以明确显示“this”。

公共类树 {

public Tree leftChild { get; set; }
public Tree rightChild { get; set; }

public object value { get; set; }   

public void InOrder()
{
    if(this.leftChild != null)
    {
        this.leftChild.InOrder();
    }

    Console.WriteLine(this.value);
    if(this.rightChild != null)
    {
        this.rightChild.InOrder();
    }
}

当您输入InOrder（）时，当前对象为'this'。递归调用是在对象'this.leftChild'上进行的，该对象与'this'不同（实际上它是子对象）。这就是递归的发生方式。

Answer 3

当你正在学习面向对象时，让我们看看这是否有帮助（我知道这并非如此所说的那么严格，只是在这里有所帮助）。

在结构化方面，你会这样做：

void InOrder(Tree node){ ... }

然后调用InOrder(leftChild)。这可以理解为：函数InOrder，请使用leftChild作为node参数运行自己。

使用对象，您有：

class Tree{
    void InOrder(){ ... }
}

然后调用leftChild.InOrder()。这可以理解为：对象leftChild，请运行您的方法InOrder。

因此，您不需要执行leftChild=leftChild.leftChild之类的操作，因为您告诉对象运行各自的方法，而不是使用不同参数运行的方法。也就是说，该方法运行多次，每次都使用不同的节点。

请注意，在OO中，每个方法都包含在一个类中，这明确意味着每个（非静态）方法都接收该类型的参数，即this（我们要求运行该方法的对象）

递归调用以及对象如何在树中迭代

3 个答案: