低效二叉搜索树平衡算法

Question

I am working on a project with Binary Search trees. This project requires me to create a method called isBalanced that checks if a binary search tree is balanced within a tolerance. I was able to figure out how to do this but it is dreadfully slow. I was wondering if anyone had any tips to make it more efficient. By the way, .getLeftChild() and .getRightChild() have to return IllegalStateExceptions if the child is null. I would much prefer them to return null personally.

Here is a snippet of my code:

@Override
public <T> int getDepth(BinaryTreeNode<T> root) {
    return recDepth(root,0);
}

public <T> int recDepth(BinaryTreeNode<T> root,int depth) {
    int leftTree,rightTree;
    if(!root.hasLeftChild()&&!root.hasRightChild()) return depth;

    if(!root.hasLeftChild()) leftTree = 0;
    else                     leftTree = recDepth(root.getLeftChild(),depth+1);

    if(!root.hasRightChild()) rightTree = 0;
    else                      rightTree = recDepth(root.getRightChild(),depth+1);

    if(rightTree>leftTree) return rightTree; 
    else                   return leftTree;
}

@Override
public <T> boolean isBalanced(BinaryTreeNode<T> root, int tolerance) {
    if(tolerance<0) throw new IllegalArgumentException("Can't have negative tolerance");
    if(root==null) throw new NullPointerException();
    return recBalanced(root,tolerance);
}

public <T> boolean recBalanced(BinaryTreeNode<T> root, int tolerance){
    try{
    if(Math.abs(getDepth(root.getLeftChild())-getDepth(root.getLeftChild()))<=tolerance){
        return recBalanced(root.getLeftChild(),tolerance)&&recBalanced(root.getRightChild(),tolerance);
    }else return false;
    } catch (IllegalStateException e){
        if(root.hasLeftChild()&&getDepth(root.getLeftChild())>tolerance-1) return false;
        else if(root.hasRightChild()&&getDepth(root.getRightChild())>tolerance-1) return false;
        else return true;
    }
}

Thanks in advance for any help.

Answer 1

Your problem of efficiency comes from the fact that you are traversing the same elements several times to compute the depth of a subtree and then the depth of its right and left subtrees.

When you have such overlapping problems that can be deduced by smaller problems, a bell must ring in your head : dynamic programming . You can compute a BinaryTreeNode<Integer> , that would contain the depth of each corresponding node (this tree would have the same shape as the original tree). You would then only need to traverse this tree once to perform your computation, for a total time complexity of O(n) (a memory used of O(n) however).

public BinaryTreeNode<Integer> computeDepthTree(BinaryTreeNode<T> bt) {
    return computeDepth(bt,0);
}

public BinaryTreeNode<Integer> computeDepthTree(BinaryTreeNode<T> bt, int depth) {
    BinaryTreeNode<Integer> result = new BinaryTreeNode<>(depth);
    if (bt.getLeftNode() != null)
        result.setLeftNode(computeDepthTree(bt.getLeftNode(),depth + 1));

    if (bt.getRightNode() != null)
        result.setRightNode(computeDepthTree(bt.getRightNode(),depth + 1));

    return result;
}

With this tree computed, when traversing a given node, you will get access to its depth in O(1) so the comparison of depth between child nodes of a same parent is going to be cheap !