C# 如果树中的所有叶子都等于其父叶，则返回true的操作

嗨，我尝试过这个，但它不起作用，我需要写一个返回真的操作，如果树中的所有叶子都等于它们的父值，请帮助我进行测试，也许这是一个主要问题

主要内容：

static void Main（字符串[]args）
{
节点t1，t2，bt1，bt2，bt；
t1=新的BinNode（3）；
t2=新的BinNode（3）；
t2.SetLeft（新BinNode（null，3，新BinNode（3））；
bt1=新的BinNode（t1，3，t2）；
bt1=新的BinNode（null，3，bt1）；
t1=新的BinNode（3）；
t2=新的BinNode（3）；
t2.SetLeft（新的BinNode（3））；
t2.SetRight（新BinNode（新BinNode（3），3，null））；
bt2=新的BinNode（t1，3，t2）；
bt=新的BinNode（bt1、3、bt2）；
控制台写入线（SumTree（bt））；
控制台写入线（页计数器（bt））；
Console.WriteLine（countwhoshatwosameson（bt））；
Console.WriteLine（IsleAfeQualHisDather（bt））；
Console.ReadLine（）；
}

操作：

 public static  bool IsLeafEqualHisFather(BinNode<int> Head)
    {
        if (Head != null)
        {
            if (IsLeaf(Head))
                return true;
            if (IsLeaf(Head.GetRight()) == true && (Head.GetRight().GetValue() == Head.GetValue()) || IsLeaf(Head.GetLeft()) == true && (Head.GetLeft().GetValue() == Head.GetValue()))
            {
                return IsLeafEqualHisFather(Head.GetRight()) && IsLeafEqualHisFather(Head.GetLeft());
            }

        }
        return false;
    }

公共静态布尔ISLEAFEQUALHISPADER（BinNode头）
{
if（Head！=null）
{
if（IsLeaf（头））
返回true；
if（IsLeaf（Head.GetRight（））==true&&（Head.GetRight（）.GetValue（）==Head.GetValue（））| | IsLeaf（Head.GetLeft（））==true&（Head.GetLeft（）.GetValue（）==Head.GetValue（））
{
返回isleafequalhisfader（Head.GetRight（））&isleafequalhisfader（Head.GetLeft（））；
}
}
返回false；
}

基本上，您需要首先检查给定的节点是null还是leaf。如果不是，则需要确定左侧和右侧节点是否为null，如果不是，则确定它们是树叶还是子树。如果它们是叶子，则需要将值与头部进行比较，或者如果它们是子树，则需要递归调用子树上的方法

public static  bool AllLeavesEqualToParent(BinNode<int> Head)
{
    if (Head == null)
        return false; // no leaves and no parent.

    if (IsLeaf(Head))
        return false; // head is a leaf, so there is no parent.

    var right = head.GetRight();
    var left = head.GetLeft();
    if(left != null) 
    {
        if (IsLeaf(left))
        {
            if (left.GetValue() != Head.GetValue())    
                return false; // left leaf didn't match
        }
        else if(!AllLeavesEqualToParent(left))
            return false; // left sub tree has leaf that doesn't match parent.
    }

    if(right!= null) 
    {
        if (IsLeaf(right))
        {
            if (right.GetValue() != Head.GetValue())    
                return false; // right leaf didn't match
        }
        else if(!AllLeavesEqualToParent(right))
            return false; // right sub tree has leaf that doesn't match parent.
    }

    return true; //Both left and right are either null (but not both), a leaf that matches
                 // the head, or sub trees with all leaves that match their parents.
}

public static bool AllLeavesEqualToParent（BinNode Head）
{
if（Head==null）
return false；//没有叶子也没有父元素。
if（IsLeaf（头））
return false；//head是一个叶子，因此没有父元素。
var right=head.GetRight（）；
var left=head.GetLeft（）；
if（左！=null）
{
if（岛叶（左））
{
if（left.GetValue（）！=Head.GetValue（））
return false；//左叶不匹配
}
如果（！AllLeavesEqualToParent（左））
return false；//左子树的叶与父树不匹配。
}
if（右！=null）
{
如果（岛（右））
{
if（right.GetValue（）！=Head.GetValue（））
return false；//右叶不匹配
}
如果（！AllLeavesEqualToParent（右））
return false；//右子树的叶与父树不匹配。
}
return true；//left和right都为null（但不是同时为null），这是一个匹配的叶
//头部或子树，其所有叶子与其父母相配。
}

基本上，您需要首先检查给定的节点是null还是leaf。如果不是，则需要确定左侧和右侧节点是否为null，如果不是，则确定它们是树叶还是子树。如果它们是叶子，则需要将值与头部进行比较，或者如果它们是子树，则需要递归调用子树上的方法

public static  bool AllLeavesEqualToParent(BinNode<int> Head)
{
    if (Head == null)
        return false; // no leaves and no parent.

    if (IsLeaf(Head))
        return false; // head is a leaf, so there is no parent.

    var right = head.GetRight();
    var left = head.GetLeft();
    if(left != null) 
    {
        if (IsLeaf(left))
        {
            if (left.GetValue() != Head.GetValue())    
                return false; // left leaf didn't match
        }
        else if(!AllLeavesEqualToParent(left))
            return false; // left sub tree has leaf that doesn't match parent.
    }

    if(right!= null) 
    {
        if (IsLeaf(right))
        {
            if (right.GetValue() != Head.GetValue())    
                return false; // right leaf didn't match
        }
        else if(!AllLeavesEqualToParent(right))
            return false; // right sub tree has leaf that doesn't match parent.
    }

    return true; //Both left and right are either null (but not both), a leaf that matches
                 // the head, or sub trees with all leaves that match their parents.
}

public static bool AllLeavesEqualToParent（BinNode Head）
{
if（Head==null）
return false；//没有叶子也没有父元素。
if（IsLeaf（头））
return false；//head是一个叶子，因此没有父元素。
var right=head.GetRight（）；
var left=head.GetLeft（）；
if（左！=null）
{
if（岛叶（左））
{
if（left.GetValue（）！=Head.GetValue（））
return false；//左叶不匹配
}
如果（！AllLeavesEqualToParent（左））
return false；//左子树的叶与父树不匹配。
}
if（右！=null）
{
如果（岛（右））
{
if（right.GetValue（）！=Head.GetValue（））
return false；//右叶不匹配
}
如果（！AllLeavesEqualToParent（右））
return false；//右子树的叶与父树不匹配。
}
return true；//left和right都为null（但不是同时为null），这是一个匹配的叶
//头部或子树，其所有叶子与其父母相配。
}

这里的主要问题似乎是，如果整个big

if

表达式的计算结果为

true

，则只执行递归检查。但这只有在你已经在看树叶的时候才是真的，所以如果你从一棵大树的顶端开始，你就看不见了

让我们简化它-检查左侧是否通过测试。这意味着以下情况之一： 1.左侧节点为

null

2.左侧节点是叶节点，其值与当前节点相同 3.左侧节点不是叶节点，并且通过了

isleafequalhisfader

测试

对右侧重复相同的步骤。然后检查他们是否都通过了考试

旁注：有（几乎）永远不要使用

[某物]==true

<代码>[something]本身就可以达到这个目的

public static  bool IsLeafEqualHisFather(BinNode<int> current)
{
    if (current != null)
    {
        if (IsLeaf(current))
        {
            return true;
        }

        var currentValue = current.GetValue();

        var left = current.GetLeft();
        var leftPasses = left == null || 
            IsLeaf(left) ? left.GetValue() == currentValue : IsLeafEqualHisFather(left);

        var right = current.GetRight();
        var rightPasses = right == null || 
            IsLeaf(right) ? left.GetValue() == currentValue : IsLeafEqualHisFather(left));

        return leftPasses && rightPasses;            
    }

    return false;
}

public static bool isleafequalhispaden（当前BinNode）
{
如果（当前！=null）
{
如果（IsLeaf（当前））
{
返回true；
}
var currentValue=current.GetValue（）；
var left=current.GetLeft（）；
var leftpasss=left==null | |
IsLeaf（左）？left.GetValue（）==currentValue:IsLeafeQualHisFard（左）；
var right=current.GetRight（）；
var rightPasses=right==null | |
IsLeaf（右）？left.GetValue（）==currentValue:IsLeafeQualHisFard（左））；
返回LeftPass&&RightPass；
}
返回false；
}

看起来这里的主要问题是你