你如何以 O(log n) 倍的复杂度计算平衡二叉搜索树的高度？

Question

I understand that in order to compute the height of a Binary Search Tree in O(n) we can use the following function

public static int treeHeight(Node root) {
      if (root == null) {
         return -1;
      }

      int left = treeHeight(root.left) + 1;
      int right = treeHeight(root.right) + 1;

      return Math.max(left, right);
   }  

However, given the fact that the tree is [balanced][2] how can we calculate the height of Binary Search Tree in O(log n).

The given problem:

Answer 1

It's not possible.

If the bottom row were filled out in a predictable fashion it could be done. For example, if the last row were always filled out left-to-right you could descend down the left side in O(log n) time since the left side would be guaranteed to have max height.

In the problem statement the nodes in the bottom row can be anywhere. The exact height can't be computed in O(log n) time. You can get within 1 of the height in O(log n) steps, but to get the exact height you may have to examine up to n/2 nodes at the bottom of the tree to find the stragglers (if any).

The worst case is if the last level is completely full and every single node in the last level has to be checked for children. There would be n/2 nodes and two checks per node, thus n checks in total. There wouldn't be any children in this case, but it'd still take O(n) checks to verify it.