Java, Binary tree remove method

Question

I am trying to write a remove(node cRoot, Object o) function for a sorted binary tree.

Here is what I have so far:

private boolean remov         


        

Answer 1

I found this code on Habrahabr. I've just added comments.

public void remove (T1 k){
    Node<T1,T2> x = root, y = null;
    // from while to if(x == null) - searching for key
    while(x != null){
        int cmp = k.compareTo(x.key);
        if(cmp == 0){
            break;  // quit cycle if key element is found
        } else {
            y = x;
            if(cmp < 0){
                x = x.left;
            } else {
                x = x.right;
            }
        }
    }
    if(x == null) return;   // if key is not found or tree is empty
    if(x.right == null){    // if element found has not right child
        if(y == null){      // if element found is root & has not right child
            root = x.left; 
        } else {            // if element found is not root & has not right child           
            if(x == y.left) y.left = x.left;    
            else y.right = x.left;              
        }
    } else {            // element found has right child, so search for most left of rights
        Node<T1,T2> mostLeft = x.right;
        y = null;
        while(mostLeft.left != null) {
            y = mostLeft;
            mostLeft = mostLeft.left;
        }
        if(y == null){  // if right child of element found has not left child
            x.right = mostLeft.right;
        } else {        // if right child of element found has left child
            y.left = mostLeft.right;
        }
        x.key = mostLeft.key;       
        x.value = mostLeft.value;   
    }
}

Answer 2

There are generally two ways of performing a remove on the tree:

First method:

Remove the node, then replace it with either child. Then, resort the tree by doing parent-child swapping until the tree is once again sorted.

The second method:

Traverse the tree to find the next (highest or lowest) value that belongs as the root*, if it is a leaf node, swap that with the root, then trim off the value you want to remove. If it is an internal node, you will have to recursively call remove on that node. Repeat until a leaf node is removed.

*What I mean is, if you convert your BST into a sorted list, then you will want to pick either value to the left or right of the root as the new root. I.e. leftmost child of the right subtree, or right most child of the left subtree.

Answer 3

The basic pseudo-code for erasing a node from a sorted tree is pretty simple:

1. erase the node value
2. find child node with maximum value
3. make it the root node
4. if it had children - goto 2 recursively

Basically what you are doing is bubbling nodes up the tree, each time the maximum of the children node in each node, so that in the end you stay with a sorted tree, and only one node missing at the end of the full path you went.

Also - see wikipedia on the subject, they have some sample code in C as well.

Answer 4

In the simple case3 you can use next algorithm:

if(removed node had left child)
{
   place left child instead of removed node;
   most_right = most right leaf in the left subtree;
   move right child of removed node as right child of most_right;
}
else
{
   place right child instead of removed node
}

In more complicated case you may need to rebalance your tree (see AVL trees, http://www.cmcrossroads.com/bradapp/ftp/src/libs/C++/AvlTrees.html for C++ example)

Answer 5

1. leaf-delete node
2. 1-child Promote the subtree
3. 2-child case replace the node with either
4. in order successor or predecessor
5. left most of the right subtree or
6. right most of the left subtree