返回二叉搜索树的高度

Question

I have two classes, BSTSet and BSTNode, which both have a height() method that returns the height. I'm getting a stackoverflow error and unsure as to what is causing it.

BSTSet

public class BSTSet <E extends Comparable<E>> extends AbstractSet <E> {

    // the root of the supporting binary search tree
    private BSTNode<E> root;

    // number of elements in the set
    private int count = 0;

    public boolean isEmpty() {
        return count == 0;
    }

    public int size() {
        return count;
    }


    public int height() {
        if(root == null) return -1;
        else return root.height();
    }
}

BSTNode

public class BSTNode <E extends Comparable<E>> {

    private E value;
    private BSTNode<E> left;
    public BSTNode<E> right;

    public BSTNode(E value) {
       this.value = value;
    }

    public E getValue() {
        return value;
    }

    public BSTNode<E> getLeft() {
        return left;
    }

    public BSTNode<E> getRight() {
        return right;
    }

    public int height() {
        if(left == null && right == null) return 0;
        if(left != null  && right == null) {UI.println("left");return left.height()+ 1; }
        else if(right != null && left == null){UI.println("right");return right.height()+ 1;}
        else{UI.println("both"); return Math.max(right.height(), left.height()) + 1;}
    }
}

If you would like anymore code or need anymore information please feel free to ask.

Answer 1

The problem is that your recursive height() method is calling height() on this . That is not how the algorithm ought to work, and it is the obvious cause of the infinite recursion loop that gives you the stack overflow.

@xgeorgekx's approach should give the right answer, but I'm not convinced that it is optimal. If the tree is balanced, then the heights of the left and right subtrees are related ... and you may not need to traverse both sides. If you can avoid that, then the height method can be implemented as O(logN) not O(N) .

I suspect that your original approach is trying to be O(logN) ...

Answer 2

if(left == null && right == null) return 0;

change to

if(left == null && right == null) return 1;

If a node has no children it still has height of 1

Then just make a recursive call like this else return Max(left.height(), right.tHeight) + 1;

By definition the height of a node is the maximum height of it's sub-tress + 1

The stack overflow is due to calling the height() method on the same node here:

else if(left != null && right == null || left == null && right != null) return height()+ 1;
else return height()+ 2;

I just wanna throw this in. If you want a single node, to start at height 0 obviously keep the if(left == null && right == null) return 0;