BST中节点的深度，包括重复项

Question

i have implemented a function to find the depth of a node in a binary search tree but my implementation does not take care of duplicates. I have my code below and would like some suggestions on how to consider duplicates case in this function. WOuld really appreciate your help.

public int depth(Node n) {
    int result=0;
    if(n == null || n == getRoot())
        return 0;

    return (result = depth(getRoot(), n, result));
}
public int depth(Node temp, Node n, int result) {
    int cmp = n.getData().compareTo(temp.getData());

    if(cmp == 0) {
        int x = result;
        return x;
    }
    else if(cmp < 0) {
            return depth(temp.getLeftChild(), n, ++result);
        }
        else {
            return depth(temp.getRightChild(), n, ++result);
        }                   
}

Answer 1

Well, if there's duplicates, then the depth of a node with a given value doesn't make any sense on its own, because there may be multiple nodes with that value, hence multiple depths.

You have to decide what it means, which could be (not necessarily an exhaustive list):

• the depth of the deepest node with that value.
• the depth of the shallowest node with that value.
• the depth of the first node found with that value.
• the average depth of all nodes with that value.
• the range (min/max) of depths of all nodes with that value.
• a list of depths of all nodes with that value.
• an error code indicating your query made little sense.

Any of those could make sense in specific circumstances.

---

Of course, if n is an actual pointer to a node, you shouldn't be comparing values of nodes at all, you should be comparing pointers. That way, you will only ever find one match and the depth of it makes sense.

Something like the following pseudo-code should do:

def getDepth (Node needle, Node haystack, int value):
    // Gone beyond leaf, it's not in tree

    if haystack == NULL: return -1

    // Pointers equal, you've found it.

    if needle == haystack: return value

    // Data not equal search either left or right subtree.

    if needle.data < haystack.data:
        return getDepth (needle, haystack.left, value + 1)

    if needle.data > haystack.data:
        return getDepth (needle, haystack.right, value + 1)

    // Data equal, need to search BOTH subtrees.

    tryDepth = getDepth (needle, haystack.left, value + 1)
    if trydepth == -1:
        tryDepth = getDepth (needle, haystack.right, value + 1)

    return trydepth

The reason why you have to search both subtrees when the values are equal is because the desired node may be in either subtree. Where the values are unequal, you know which subtree it's in. So, for the case where they're equal, you check one subtree and, if not found, you check the other.

Answer 2

In the code you show, there is no way to prefer one node with same value over another. You need to have some criteria for differentiation. You can retrieve the list of all duplicate nodes depths using the following approach, for example:

1. Find the depth of your node.
2. Find depth of the same node for the left subtree emerging from the found node - stop if not found.
3. Add depth of the previously found node (in 1) to the depth of the duplicate
4. Find depth of the same node for the right subtree emerging from the found node (in 1) - stop if not found.
5. Add depth of the previously found node (in 1) to the depth of the duplicate
6. Repeat for left and right subtrees.

Also see here: What's the case for duplications in BST?