二叉搜索树

public class BinarySearchTree {
    private TreeNode root;

    private static class TreeNode {
        int data;
        TreeNode left;
        TreeNode right;
        TreeNode parent;

        public TreeNode(int data) {
            this.data = data;
        }

        @Override
        public String toString() {
            return "" + data;
        }
    }

    public void insert(TreeNode z) {
        TreeNode y = null;
        TreeNode x = root;
        while (x != null) {
            y = x;
            if (z.data < x.data) {
                x = x.left;
            } else {
                x = x.right;
            }
        }
        z.parent = y;
        if (y == null)
            root = z;
        else if (z.data < y.data)
            y.left = z;
        else
            y.right = z;
    }

    /**
     * 二叉搜索树内移动子树（用另一棵子树替换一棵子树，并成为其父结点的孩子结点）
     *
     * @param u 被替换子树的根结点
     * @param v 替换子树的根结点
     */
    public void transplant(TreeNode u, TreeNode v) {
        if (u.parent == null) {
            root = v;
        } else if (u == u.parent.left) {
            u.parent.left = v;
        } else {
            u.parent.right = v;
        }

        if (v != null)
            v.parent = u.parent;
    }

    public void delete(TreeNode z) {
        if (z.left == null) // 没有左儿子
            transplant(z, z.right);
        else if (z.right == null) // 有左儿子，没有右儿子
            transplant(z, z.left);
        else {
            // 有左右儿子
            TreeNode y = treeMinimum(z.right);
            if (y.parent != z) {
                transplant(y, y.right);
                y.right = z.right;
                y.right.parent = y;
            }
            transplant(z, y);
            y.left = z.left;
            y.left.parent = y;
        }
    }

    /**
     * 中序遍历
     */
    public static void inorderTreeWalk(TreeNode treeNode) {
        if (treeNode != null) {
            inorderTreeWalk(treeNode.left);
            System.out.println(treeNode.data);
            inorderTreeWalk(treeNode.right);
        }
    }

    /**
     * 先序遍历
     */
    public static void preorderTreeWalk(TreeNode treeNode) {
        if (treeNode != null) {
            System.out.println(treeNode.data);
            preorderTreeWalk(treeNode.left);
            preorderTreeWalk(treeNode.right);
        }
    }

    /**
     * 后序遍历
     */
    public static void postorderTreeWalk(TreeNode treeNode) {
        if (treeNode != null) {
            postorderTreeWalk(treeNode.left);
            postorderTreeWalk(treeNode.right);
            System.out.println(treeNode.data);
        }
    }

    /**
     * 树查询 递归版
     */
    public static TreeNode treeSearch(TreeNode treeNode, int k) {
        if (treeNode == null || treeNode.data == k) {
            return treeNode;
        }

        if (k < treeNode.data) {
            return treeSearch(treeNode.left, k);
        } else {
            return treeSearch(treeNode.right, k);
        }
    }

    /**
     * 树查询 循环版
     */
    public static TreeNode interactiveTreeSearch(TreeNode treeNode, int k) {
        while (treeNode != null && treeNode.data != k) {
            if (k < treeNode.data) {
                treeNode = treeNode.left;
            } else {
                treeNode = treeNode.right;
            }
        }
        return treeNode;
    }

    /**
     * 最小关键字元素
     */
    public static TreeNode treeMinimum(TreeNode treeNode) {
        while (treeNode.left != null)
            treeNode = treeNode.left;
        return treeNode;
    }

    /**
     * 最大关键字元素
     */
    public static TreeNode treeMaximum(TreeNode treeNode) {
        while (treeNode.right != null)
            treeNode = treeNode.right;
        return treeNode;
    }

    /**
     * 后继
     */
    public static TreeNode treeSuccessor(TreeNode x) {
        if (x.right != null) { // 若右节点不为空，它的后继为右子树中最左的结点
            return treeMinimum(x.right);
        }

        // 如果x的右子树为空，且x有一个后继y，那么y一定是x最底层的祖先，并且其左儿子也是x的祖先
        TreeNode y = x.parent;
        while (y != null && y.right == x) {
            x = y;
            y = y.parent;
        }
        return y;
    }

    /**
     * 前驱
     */
    public static TreeNode treePredecessor(TreeNode x) {
        if (x.left != null) { // 若左节点不为空，它的前驱为左子树中最大的结点
            return treeMaximum(x.left);
        }

        // 如果x的左子树为空，且x有一个前驱y，那么y一定是x最底层的祖先，并且其右儿子也是x的祖先
        TreeNode y = x.parent;
        while (y != null && y.left == x) {
            x = y;
            y = y.parent;
        }
        return y;
    }

    private TreeNode getRoot(TreeNode treeNode) {
        while (treeNode != null && treeNode.parent != null) {
            treeNode = treeNode.parent;
        }
        return treeNode;
    }

    public static void main(String[] args) {
        BinarySearchTree binarySearchTree = new BinarySearchTree();

        TreeNode node1 = new TreeNode(1);
        TreeNode node2 = new TreeNode(2);
        TreeNode node3 = new TreeNode(3);
        TreeNode node4 = new TreeNode(4);
        TreeNode node5 = new TreeNode(5);
        TreeNode node6 = new TreeNode(6);
        TreeNode node7 = new TreeNode(7);

        binarySearchTree.insert(node4);
        binarySearchTree.insert(node2);
        binarySearchTree.insert(node6);
        binarySearchTree.insert(node1);
        binarySearchTree.insert(node3);
        binarySearchTree.insert(node5);
        binarySearchTree.insert(node7);

//        inorderTreeWalk(binarySearchTree.root);

        binarySearchTree.delete(node6);
        binarySearchTree.delete(node4);
        inorderTreeWalk(binarySearchTree.root);

//        System.out.println("---");
//        preorderTreeWalk(root);
//        System.out.println("---");
//        postorderTreeWalk(root);
//
//
//        TreeNode treeNode = treeSearch(root, 5);
//        System.out.println(treeNode);
//
//        treeNode = interactiveTreeSearch(root, 2);
//        System.out.println(treeNode);

//        System.out.println(treeSuccessor(node6).getData());
//        System.out.println(treePredecessor(node5).getData());
    }
}

删除结点的4种情况