二叉查找树删除结点

题目

• 二叉查找树中删除任意一个结点

解法

• 构建树

public class BTree {
    public int value;
    public BTree parent;
    public BTree left;
    public BTree right;

    public BTree(){}
    public BTree(int value) {
        this.value = value;
    }
}

• 删除结点

    /**
     * 删除树中某一个节点
     *
     * @param root
     * @param key
     * @return
     */
    public static BTree deleteNode(BTree root, BTree key) {
        if (root == null || key == null) {
            return root;
        }

        // 查找树结点
        BTree node = searchNode(root, key);
        if (node == null) {
            System.out.println("not found");
        }

        // 1、同时有左侧和右侧结点
        if (node.left != null && node.right != null) {
            // 查找后继结点
            BTree tailNode = findTailNodeMethod(node);
            node.value = tailNode.value;
            node = tailNode;
        }
        // 2、只有左侧或者右侧结点
        BTree childNode;
        if (node.left != null) {
            childNode = node.left;
        } else {
            childNode = node.right;
        }
        // 子节点与父节点相连
        if (childNode != null) {
            childNode.parent = node.parent;
        }
        // 3、无左侧结点和右侧结点
       if (node == node.parent.left) {
            node.parent.left = childNode;
        } else {
            node.parent.right = childNode;
        }
        return node;

    }

• 查找结点

  /**
     * 查找结点
     * @param root
     * @param key
     * @return
     */
    private static BTree searchNode(BTree root, BTree key) {
        if (root == null) return null;
        if (root.value == key.value) {
            return root;
        } else if (root.value > key.value) {
            return searchNode(root.left, key);
        } else {
            return searchNode(root.right, key);
        }
    }

• 查找后继结点

 /**
     * 查找后继结点
     * @param bTree
     * @return
     */
    private static BTree findTailNodeMethod(BTree bTree) {
        if (bTree.right != null) {
            BTree rightNode = bTree.right;
            while (rightNode.left != null) {
                rightNode = rightNode.left;
            }
            return rightNode;
        } else {
            BTree parent = bTree.parent;
            while (parent != null && parent.left != bTree) {
                bTree = parent;
                parent = parent.left;
            }
            return parent;
        }
    }

• 中序遍历

 /**
     * 中序遍历
     * @param tree
     */
    public  static void midOrderTree(BTree tree){
        if (tree!=null){
            midOrderTree(tree.left);
            System.out.println("value === "+tree.value);
            midOrderTree(tree.right);
        }
    }

main方法测试

   public static void main(String[] args) {
        int[] array = new int[]{50, 30, 80, 20, 35, 34, 32, 40, 70, 75, 100};
        // 构建树
        BTree bTree=new BTree();
        for (int i=0;i<array.length;i++){
            insert(bTree,new BTree(array[i]));
        }
        midOrderTree(bTree);
        System.out.println(" 删除结点-----------");
        deleteNode(bTree,new BTree(20));
        midOrderTree(bTree);
    }

日志

value === 0
value === 20
value === 30
value === 32
value === 34
value === 35
value === 40
value === 50
value === 70
value === 75
value === 80
value === 100
 删除结点-----------
value === 0
value === 30
value === 32
value === 34
value === 35
value === 40
value === 50
value === 70
value === 75
value === 80
value === 100

参考

Blog