C# 如何迭代求BST的高度？

我写了迭代法，用来计算树的高度。但在某些情况下，它不能正常工作。例如： 10 1. 2. 3. 4. 5. 18 17 16 15 14 13 有什么问题吗。根据这个序列，树的高度是6，其中我的代码显示为5。

问题：

您将在第一个循环中找到最左侧节点的深度，在第二个循环中找到最右侧节点的深度，并且从不询问任何涉及向左和向右移动的节点

解决方案：

有一个单独的循环，该循环深入左侧节点，但将其“跳过”的每个右侧节点添加到队列中。当左侧节点用完时，从队列中弹出一个节点并继续，直到队列变空。您需要存储放入该节点队列中的每个节点的高度。

问题：

您将在第一个循环中找到最左侧节点的深度，在第二个循环中找到最右侧节点的深度，并且从不询问任何涉及向左和向右移动的节点

解决方案：

---

有一个单独的循环，该循环深入左侧节点，但将其“跳过”的每个右侧节点添加到队列中。当左侧节点用完时，从队列中弹出一个节点并继续，直到队列变空。您需要存储放入该节点队列中的每个节点的高度。

您使用的是两个循环，但每个循环只调查节点的一侧，但树中的每个节点都有两侧。您应该全部调查。您可以通过递归调用来实现

  public void HeightIterative()
    {
        int counter = 0;
        int counter2 = 0;
        TreeNode current=root;

        if(current != null)
        {
            while(current.LeftNode!=null)
            {
                counter++;
                current = current.LeftNode;
            }
            while(current.RightNode!=null)
            {
                counter2++;
                current = current.RightNode;
            }
        }

        int res = 1+Math.Max(counter, counter2);
        Console.WriteLine("The Height Of Tree Is: "+res);
    }

迭代版本：

private int GetLen(TreeNode node)
{
  var result = 0;

  if(node != null)
  {
    result = Math.Max(GetLen(node.LeftNode), GetLen(node.RightNode)) + 1;
  }

  return result;
}

public void HeightIterative()
{
  int res = GetLen(root);
  Console.WriteLine("The Height Of Tree Is: "+res);
}

私有类节点信息
{
公共节点信息（TreeNode节点，int len）
{
节点=节点；
Len=Len；
}
公共树节点{get；private set；}
public int Len{get；private set；}
}
公共空间高度（）
{
int maxLen=0；
var queue=新队列（）；
排队（新节点信息（根，1））；
而（queue.Count>0）
{
var item=queue.Dequeue（）；
var current=项目节点；
var currentLen=item.Len；
if（current.LeftNode！=null）
{
Enqueue（新节点信息（current.LeftNode，currentLen+1））；
}
if（current.RightNode！=null）
{
排队（新节点信息（current.RightNode，currentLen+1））；
}
如果（currentLen>maxLen）
{
maxLen=当前Len；
}
}
Console.WriteLine（“树的高度为：“+maxLen”）；
}

您正在使用两个循环，但每个循环只调查节点的一侧，但树中的每个节点都有两个侧面，您应该全部调查。您可以通过递归调用来实现

  public void HeightIterative()
    {
        int counter = 0;
        int counter2 = 0;
        TreeNode current=root;

        if(current != null)
        {
            while(current.LeftNode!=null)
            {
                counter++;
                current = current.LeftNode;
            }
            while(current.RightNode!=null)
            {
                counter2++;
                current = current.RightNode;
            }
        }

        int res = 1+Math.Max(counter, counter2);
        Console.WriteLine("The Height Of Tree Is: "+res);
    }

迭代版本：

private int GetLen(TreeNode node)
{
  var result = 0;

  if(node != null)
  {
    result = Math.Max(GetLen(node.LeftNode), GetLen(node.RightNode)) + 1;
  }

  return result;
}

public void HeightIterative()
{
  int res = GetLen(root);
  Console.WriteLine("The Height Of Tree Is: "+res);
}

私有类节点信息
{
公共节点信息（TreeNode节点，int len）
{
节点=节点；
Len=Len；
}
公共树节点{get；private set；}
public int Len{get；private set；}
}
公共空间高度（）
{
int maxLen=0；
var queue=新队列（）；
排队（新节点信息（根，1））；
而（queue.Count>0）
{
var item=queue.Dequeue（）；
var current=项目节点；
var currentLen=item.Len；
if（current.LeftNode！=null）
{
Enqueue（新节点信息（current.LeftNode，currentLen+1））；
}
if（current.RightNode！=null）
{
排队（新节点信息（current.RightNode，currentLen+1））；
}
如果（currentLen>maxLen）
{
maxLen=当前Len；
}
}
Console.WriteLine（“树的高度为：“+maxLen”）；
}

有一种方法，除了用于存储节点的队列之外，不需要任何额外的空间

添加当前元素的子节点并记住队列的大小

让每个出列调用递减计数器

当计数器达到零时，这意味着我们完成了当前电平

重复并计数计数器达到零的次数-这是树的深度/高度

代码如下：

private class NodeInfo
{
  public NodeInfo(TreeNode node, int len)
  {
    Node = node;
    Len = len;
  }

  public TreeNode Node {get; private set;}
  public int Len {get; private set;}
}

public void HeightIterative()
{
    int maxLen = 0;

    var queue = new Queue<NodeInfo>();
    queue.Enqueue(new NodeInfo(root, 1));

    while (queue.Count > 0)
    {
        var item = queue.Dequeue();
        var current = item.Node;
        var currentLen = item.Len;

        if (current.LeftNode != null)
        {
            queue.Enqueue(new NodeInfo(current.LeftNode, currentLen + 1));
        }

        if (current.RightNode != null)
        {
            queue.Enqueue(new NodeInfo(current.RightNode, currentLen + 1));
        }

        if (currentLen > maxLen)
        {
            maxLen = currentLen;
        }
    }

    Console.WriteLine("The Height Of Tree Is: " + maxLen);
}

public int treeDepth（节点根）{
整数高度=0；
int counterNodesInLevel=1；
if（root！=null）
{
队列=新队列（）
queue.enqueue（root）；
而（！queue.isEmpty（））{
节点当前=queue.dequeue（）；
反向节点sinlevel-=1；
if（当前左！=null）{
队列。排队（当前。左侧）
}
if（当前.右！=null）{
queue.enqueue（current.right）
}
if（counterNodesInLevel==0）{
高度+=1；
counterNodesInLevel=queue.Size（）；
}                    
}    
}    
返回高度；
}    

---

时间复杂度是O（N），空间复杂度是O（N）

有一种方法不需要任何额外的空间，除了用于存储节点的队列

添加当前元素的子节点并记住队列的大小

让每个出列调用递减计数器

当计数器达到零时，这意味着我们完成了当前电平

重复并计数计数器达到零的次数-这是树的深度/高度

代码如下：

private class NodeInfo
{
  public NodeInfo(TreeNode node, int len)
  {
    Node = node;
    Len = len;
  }

  public TreeNode Node {get; private set;}
  public int Len {get; private set;}
}

public void HeightIterative()
{
    int maxLen = 0;

    var queue = new Queue<NodeInfo>();
    queue.Enqueue(new NodeInfo(root, 1));

    while (queue.Count > 0)
    {
        var item = queue.Dequeue();
        var current = item.Node;
        var currentLen = item.Len;

        if (current.LeftNode != null)
        {
            queue.Enqueue(new NodeInfo(current.LeftNode, currentLen + 1));
        }

        if (current.RightNode != null)
        {
            queue.Enqueue(new NodeInfo(current.RightNode, currentLen + 1));
        }

        if (currentLen > maxLen)
        {
            maxLen = currentLen;
        }
    }

    Console.WriteLine("The Height Of Tree Is: " + maxLen);
}

public int treeDepth（节点根）{
整数高度=0；
int counterNodesInLevel=1；
if（root！=null）
{
队列=新队列（）
queue.enqueue（root）；
而（！queue.isEmpty（））{
节点当前=queue.dequeue（）；
反向节点sinlevel-=1；
if（当前左！=null）{
队列。排队（当前。左侧）
}
if（当前.右！=null）{
queue.enqueue（current.right）
}
if（counterNodesInLevel==0）{
高度+=1；
counterNodesInLevel=queue.Size（）；
}                    
}    
}    
返回高度；
}    

时间复杂度为O（N），空间复杂度为O（N）

public int Height（）
{
int结果=G