Question

我有一个项目要做，并且我已经完成了所有工作，除了需要在其中找到节点数最多的最高级别的地方。这是我的代码，但是我似乎无法弄清楚该怎么做：

 public int fullLevel() {
    int height = 1;
    int count = 1;
    fullLevel(root, height, count);
    return height;
} 

private int fullLevel(Node temp, int height, int count) {
    int height2 = (int) Math.pow(2, height - 1);

    if (temp == null) {
        return 0;
    }
    if (count == height2 && temp.left != null && temp.right != null) {
        count = 0;
        return fullLevel(temp.right, count, height + 1) + fullLevel(temp.left, count, height + 1);
    } else if (count != height2) {
        return fullLevel(temp.right, count + 1, height) + fullLevel(temp.left, count + 1, height);
    } else {
        return height;
    }
}

问题询问：“确定已满的最高级别，或者等效地确定该级别的最大节点数。” -必须使用递归。谢谢！

我不擅长递归，所以请提前对不起！

Answer 1

在比较每个级别中的实际子代数与该级别可能的子代数方面，您处于正确的轨道。理想的方法是使用队列执行级别顺序遍历并返回最高的完整级别。但是，由于您无法使用递归，因此问题就成为在递归调用中水平维护计数的问题之一。一个幼稚的解决方案是为每个高度创建一个计数列表，然后返回该列表中的最后一个完整高度。

仅当两个孩子都存在时，优化才会重新进行-显然，如果缺少孩子，则不可能在树的更深处进行完整级别的搜索，我们可以结束搜索。

public static int fullLevel(Node root) {
    ArrayList<Integer> levelCounts = new ArrayList<>();
    levelCount(root, 0, levelCounts);

    for (int i = levelCounts.size() - 1; i >= 0; i--) {
        if ((int)Math.pow(2, i) == levelCounts.get(i)) {
            return i;
        }
    }

    return -1;
}

private static void levelCount(Node root, int height, ArrayList<Integer> levelCounts) {
    if (root != null) {
        if (height >= levelCounts.size()) {
            levelCounts.add(0);
        }

        levelCounts.set(height, levelCounts.get(height) + 1);

        if (root.left != null && root.right != null) {
            levelCount(root.left, height + 1, levelCounts);
            levelCount(root.right, height + 1, levelCounts);
        }
    }
}

以下示例树的输出为2（零索引）：

       ____1____
      /         \ 
    _2_        __3__
   /   \      /     \
  4     5    6      _7_    <-- tallest full level
 / \   /    / \    /   \
8   9 10   11  12 13   14

Try it!

确定最高级别已满-二进制搜索树

1 个答案: