验证给定级别的所有节点在二叉树中具有不同的值

Question

我的问题是，这个问题可以在不使用任何数据结构（堆栈，列表等）的情况下解决，还是需要一个？ （如果可能的话，我也希望看到两种情况下的解决方案）。

---

问题：

有一个BinaryTree类，表示包含整数值的二叉树。 假设已经实现了方法：

public BinaryTree right();  // returns right children
public BinaryTree left();   // returns left children
public int val();   // returns value of root node.

实现以下递归方法：

public static boolean allDifferentAtLevel(BinaryTree a, int lev){...}

接收整数的二叉树模型和返回true只有在水平列弗所有的节点的所有值具有不同的值。

---

在此先感谢您的时间。

Answer 1

我们可以使用HashSet<Integer>来跟踪lev级别的数据。

public static boolean allDifferentAtLevel(BinaryTree a, int lev){
    return checker(new HashSet<Integer>(),a,0,lev); //EmptySet, Root, CurrentLevel, Level
}

public static boolean checker(HashSet<Integer> set,BinaryTree a, int currentLevel, int lev) {
    if(a==null) //If current node of tree is null, return true.
        return true;

    if(currentLevel==lev) //If currentLevel is the required level, We don't need to move further.
                          //We can just validate the data at currentLevel and return the appropriate value.
    {
        int value=a.val();
        if(set.contains(value)) //If set contains the value, Duplication found.
            return false;

        set.add(value);
        return true;
    }

    //Check for both of the children.
    return checker(set,a.left(),currentLevel+1,lev) && checker(set,a.right(),currentLevel+1,lev);
}

Answer 2

然而，它可能效率低下 - 您可以实现两个递归函数：

1. DFS以所需级别到达所有节点
2. 从第一个函数（对于所需级别的每个节点）调用另一个函数，该函数将计算（也使用DFS）所有节点的值等于第一个函数所考虑的节点的值，并检查此计数是否等于1 。

Answer 3

是的，这可以通过递归来解决，而无需额外的数据结构。

让我们尝试定义allDifferentAtLevel(BinaryTree tree, int lev)方法对于不同的lev应该是什么样子：

对于lev=0 ，结果只是false因为级别0上的所有节点具有相同的值。 级别0上只有一个节点，因此所有节点都具有相同的值。

对于lev=1 ，检查tree.right().val() == tree.left().val() （添加null检查）是非常简单的。

对于更高级别（ lev>1 ），您应该递归调用该方法。 基本上， allDifferentAtLevel(tree.left(), lev - 1)和allDifferentAtLevel(tree.right(), lev - 1)将确保左子树和右子树满足条件。 不幸的是，这是不够的，因为左右子树之间可能有一些共同的价值。

但是可以解决这个检查，不仅仅是左右，而是所有子树的组合更深层次。 就像是：

BinaryTree ll = tree.left() == null ? null : tree.left().left();
BinaryTree lr = tree.left() == null ? null : tree.left().right();
BinaryTree rl = tree.right() == null ? null : tree.right().left();
BinaryTree rr = tree.right() == null ? null : tree.right().right();

BinaryTree ll_lr = tree.left();
BinaryTree ll_rl = new BinaryTree(0, ll, rl);
BinaryTree ll_rr = new BinaryTree(0, ll, rr);
BinaryTree lr_rl = new BinaryTree(0, lr, rl);
BinaryTree lr_rr = new BinaryTree(0, lr, rr);
BinaryTree rl_rr = tree.right();

return allDifferentAtLevel(ll_lr, lev - 1) &&
       allDifferentAtLevel(ll_rl, lev - 1) &&
       allDifferentAtLevel(ll_rr, lev - 1) &&
       allDifferentAtLevel(lr_rl, lev - 1) &&
       allDifferentAtLevel(lr_rr, lev - 1) &&
       allDifferentAtLevel(rl_rr, lev - 1);

有两个更深层次的子树（ ll ， lr ， rl ， rr ）。 但我们不能只检查这些子树，我们必须互相检查它们。 这些子树有六种可能的不同对。 为了相互检查这些子树，我们可以为每个不同的对（ ll_lr ， ll_rl ， ll_rr ， lr_rl ， lr_rr ， rl_rr ）创建一个二叉树，然后递归地检查这些二进制树中的每一个。 如果任何子树ll ， lr ， rl ， rr在lev-2具有相等的元素，则它们将具有在lev-1上具有相等元素的一对。

所以是的，这个问题可以通过递归来解决，而无需额外的数据结构。 我不认为BinaryTree是一个额外的数据结构。

话虽如此，使用像集合这样的附加数据结构可以使任务更容易。