Java二进制搜索树找到父级

Question

im working on a method to find the parent of anode. I start at the root and then go down the leaves as long as they are not null and not the node of the child.

below is my code, its a little messy because im trying to test it to see whats going wrong.

The tree that i have is

        10
      /    \
     2     20
      \   / \
       3 18 22
            /
           21

The x that is being passed in is 20 so 10 is the parent but when i run it 22 comes out as the parent. the while loop seems to not be working, is it the way ive written it?

public Node<E> findParent(E x)
{
Node<E> node = root;

System.out.println("node is " + node.getData() + " before the search");
System.out.println("The value of x is " + x);
System.out.println("The value of node.getRight is " + node.getRight().getData());
boolean test = !node.getRight().getData().equals(x);
System.out.println("does nodes data equal x " + test);
while(((node!=null) && (node.getLeft()!=null) && (!node.getLeft().getData().equals(x))) || 
 ((node != null) && (node.getRight()!=null) && (!node.getRight().getData().equals(x))))
{ System.out.println("why didnt it stop");
    if(x.compareTo(node.getData()) < 0)
    {
        node = node.getLeft();
    }
    else
    {
        node = node.getRight();
    }
}
 System.out.println("node is " + node.getData() + " after the search");
return node;
}

Answer 1

I would do it differently: do the recursion in an auxiliary method that is passed the current node and the current parent node. It makes everything much simpler:

public Node<E> findParent(E x) {
    return findParent(x, root, null);
}

public Node<E> findParent(E x, Node<E> node, Node<E> parent)
{
    if (node == null) {
        return null;
    } else if (!node.getData().equals(x)) {
        parent = findParent(x, node.getLeft(), node);
        if (parent == null) {
            parent = findParent(x, node.getRight(), node);
        }
    }
    return parent;
}

Answer 2

private static void myparent(int data, Node R) 
{
    if( (R.left!=null && R.left.data == data) || (R.right!=null) &&(R.right.data == data) )
    {
        pRoot = R;
        return;
    }
    if (R.data <= data)
        myparent(data, R.right);
    else
        myparent(data, R.left);
}

Where "Data" is the value of the node whose parent we need to search and R is the root node of the BST. pRoot is my global data structure as I used it at other operations on BST.

Answer 3

This is just pseudocode. when you are at a node x , check for the key (of child whose parent is to be found) in the left and right node. If they match, then you are already at the parent. If not then it's safe to move in the direction of the element and perform again.

Note that we check in the next level before proceeding.

while(node!=null){

  if(node.left==key || node.right==key) return node;

  if(key<node.data) node=node.left;

  else node=node.right;

  return null;
}