删除二叉搜索树中的节点

Question

This is not an homework. I am just totally blocked on this. I know what to do but I am having difficulty manipulating the tree.

It seems like the below code works for leaf nodes but does not work for other case. The following code compiles. Please help.

package com.binarytree;

import com.binarytree.Node;

public class BinaryTree1 {
    private Node root;
    private Node parent;

    public BinaryTree1(){
        root = null;
    }

    public Node getRoot() {
        return root;
    }

    public void setRoot(Node root) {
        this.root = root;
    }

    public Node insert(int data){
        return insert(root, data);
    }

    private Node insert(Node node, int data){
        if( node == null ) {
            node = new Node(data);
        }
        else{
            if (data <= node.data){
                node.left = insert(node.left, data);
            }
            else{
                node.right = insert(node.right, data);
            }
        }

        return node;
    }

    public void printTree(Node node){
        if( node == null) return;

        //System.out.println( "left: " + (node.left != null ? node.left.data : null) );
        printTree(node.left);
        System.out.print(node.data + " ");
        //System.out.println( "right: " + (node.right != null ? node.right.data : null) );
        printTree(node.right);
    }

    /**
     * case 0: no children - leaf node - delete the parent link 
     * case 1: 1 child - make the parent to point to the node child and delete
     * case 2: find min from right sub tree, copy value in targetted node and delete duplicate node
     *          (OR)
     *         find max from left sub tree, copy value in targetted node and delete duplicate node
     * @param root
     * @param data
     */
    public Node deleteNode(Node myroot, int data){
        if( myroot == null) return null;
        else if( data < myroot.data ){ //left sub tree
            myroot.left = deleteNode(myroot.left, data);
        }
        else if (data > myroot.data){
            myroot.right = deleteNode(myroot.right, data);
        }

        else{ //found the node
            //no child
            if( myroot.left == null  && myroot.right == null ){
                myroot = null;
                parent = myroot;
            }
            else if( myroot.left == null && myroot.right != null){
                parent.right = myroot.right;    
                myroot = null;
            }
            else if (myroot.left != null && myroot.right == null){
                parent.left = myroot.right;
                myroot = null;
            } //2 children
            else{
                Node temp = myroot.right;
                myroot.data = temp.data;
                myroot.right = myroot.right.right;
            }
        }

        parent = myroot;

        return parent;
    }

}


package com.binarytree;

public class RunBinaryTree1 {
    public static void main(String[] args){
        BinaryTree1 bt = new BinaryTree1();
        bt.setRoot(bt.insert(5));
        bt.setRoot(bt.insert(3));
        bt.setRoot(bt.insert(4));
        bt.setRoot(bt.insert(1));
        bt.setRoot(bt.insert(6));
        bt.setRoot(bt.insert(9));
//      bt.setRoot(bt.insert(2));

        System.out.print("Nodes in the BST (In order) are: "); bt.printTree(bt.getRoot());
        System.out.println("");

        System.out.print("Nodes in the BST (In order) are: "); bt.printTree(bt.deleteNode(bt.getRoot(), 1));
        bt.setRoot(bt.insert(1));

        //DOES NOT WORK
        System.out.print("Nodes in the BST (In order) are: "); bt.printTree(bt.deleteNode(bt.getRoot(), 6));
    }
}


package com.binarytree;

public class Node {
    Node left;
    Node right;
    int data;

    public Node(int data){
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

Answer 1

There are three possibilities to watch out for when deleting a node from a balanced tree, which is usually the case for search trees. If your trees aren't meant to be self-balancing, ignore the bits that discuss it. Even if they are self-balancing, that particular aspect is complicated and probably worthy of a different question.

Also keep in mind the example trees below aren't actually balanced, they're just being used to show the actions.

---

First, if your node is a leaf. In that case, it's easy. You just delete the node. The transition then becomes, to delete D:

  B             B
 / \           / \
A   C    ==>  A   C
     \
      D

If you're using balanced trees for this case, start balancing at the parent of the node you deleted (C) and work your way up the tree from there.

---

Second case, it has one child. In that case, you simply "bring" that child up, pointers and all. For example, deleting C in the following:

  B             B
 / \           / \
A   C    ==>  A   D
     \             \
      D             E
       \
        E

If the tree is self-balancing, you would start at the node you shifted up in to, D in this case.

---

The third case is a little trickier in that the node you're deleting has two children so you can neither delete it nor bring up a child node.

What you do in that case is to swap the data in that node with the data of its immediate predecessor, which is guaranteed to be either a leaf node or a node with a left child only.

Then you simply revert back to case 1 or 2 above and delete the predecessor node (which now contains the data you want to remove) and rebalance using the appropriate rules, if desired.

Let's say you want to delete F from the following, you first swap F with its predecessor E then delete F (from a leaf node in this case, so using case 1 above):

  B             B               B
 / \           / \             / \
A   F    ==>  A   E    ==>    A   E
   / \           / \             / \
  D   G         D   G           D   G
 / \   \       / \   \         /     \
C   E   H     C   F   H       C       H
              (swap EF)        (del F)

This works for the same reason it does in a list:

Index: 12345678
       ABCDEFGH

If you want to remove F from that list but the sixth position is somehow protected, you can swap the data at indexes 5 and 6:

Index: 12345678
       ABCDFEGH

then delete the data at index 5:

Index: 1234567
       ABCDEGH

The way you find the immediate predecessor of a node (with two children) is to go to it's left child then keep going right until the right child is NULL, pseudo-code such as:

def predecessor(n):
    pre = n.left
    while pre.right != null:
        pre = pre.right
    return pre

Answer 2

Here is something that works. That for all the help.

public class RunBinaryTreeForDeleteNode {
    public static void main(String[] args){
        BinaryTreeDeleteNode bt = new BinaryTreeDeleteNode();
        bt.setRoot(bt.insert(5));
        bt.setRoot(bt.insert(3));
        bt.setRoot(bt.insert(4));
        bt.setRoot(bt.insert(1));
        bt.setRoot(bt.insert(6));
        bt.setRoot(bt.insert(9));
//      bt.setRoot(bt.insert(2));

        //start of Testing deletion of nodes.
        System.out.print("Nodes in the BST (In order) are: "); bt.printTree(bt.getRoot());
        System.out.println("");

        System.out.print("Nodes in the BST (In order) are: "); bt.printTree(bt.deleteNode(bt.getRoot(), 1));
        bt.setRoot(bt.insert(1));
        System.out.println("");

        System.out.print("Nodes in the BST (In order) are: "); bt.printTree(bt.deleteNode(bt.getRoot(), 6));
        bt.setRoot(bt.insert(6));
        System.out.println("");

        System.out.print("Nodes in the BST (In order) are: "); bt.printTree(bt.deleteNode(bt.getRoot(), 3));
        bt.setRoot(bt.insert(3));
        System.out.println("");

        //BELOW CODE CORRUPTS THE TREE
        System.out.print("Nodes in the BST (In order) are: "); bt.printTree(bt.deleteNode(bt.getRoot(), 5));
        //bt.setRoot(bt.insert(5));
        System.out.println("");

//      System.out.print("Nodes in the BST (In order) are: "); bt.printTree(bt.getRoot());
        //System.out.println("");
        //end of Testing deletion of nodes.
    }
}




public class Node {
    Node left;
    Node right;
    int data;

    public Node(int data){
        this.data = data;
        this.left = null;
        this.right = null;
    }
}





public class BinaryTreeDeleteNode {
    private Node root;

    public BinaryTreeDeleteNode(){
        root = null;
    }

    public Node getRoot() {
        return root;
    }

    public void setRoot(Node root) {
        this.root = root;
    }

    public Node insert(int data){
        return insert(root, data);
    }

    private Node insert(Node node, int data){
        if( node == null ) {
            node = new Node(data);
        }
        else{
            if (data <= node.data){
                node.left = insert(node.left, data);
            }
            else{
                node.right = insert(node.right, data);
            }
        }

        return node;
    }

    public void printTree(Node node){
        if( node == null) return;

        //System.out.println( "left: " + (node.left != null ? node.left.data : null) );
        printTree(node.left);
        System.out.print(node.data + " ");
        //System.out.println( "right: " + (node.right != null ? node.right.data : null) );
        printTree(node.right);
    }

    /**
     * case 0: no children - leaf Node - delete the parent link 
     * case 1: 1 child - make the parent to point to the Node child and delete
     * case 2: find min from right sub tree, copy value in targetted Node and delete duplicate Node
     *          (OR)
     *         find max from left sub tree, copy value in targetted BST Node and delete duplicate Node
     * @param root
     * @param data
     */
    public Node deleteNode(Node myNode, int data) {
        if( myNode == null) return null;

        Node p, p2;

        if (data < myNode.data)
        {
            myNode.left = deleteNode(myNode.left, data);
        }
        else if( data > myNode.data)
        {
            myNode.right = deleteNode(myNode.right, data);
        }
        else
        {
            if (myNode.left == null && myNode.right == null){ //leaf node
                return null;
            }
            else if (myNode.left == null) //one child
            {
                return myNode.right;
            }
            else if (myNode.right == null) //one child
            {
                return myNode.left;
            }
            else  //2 children
            {
                p2 = myNode.right;
                p = myNode.right;

                while (p.left != null){
                    p = p.left;
                }

                p.left = myNode.left;

                return p2;
            }

        }

        return myNode;
    }

}