java数据结构和算法------二叉排序树

package iYou.neugle.search;

public class BSTree_search {
    class BSTree {
        public int data;
        public BSTree left;
        public BSTree right;
    }

    public static void main(String[] args) {
        BSTree_search bst = new BSTree_search();
        int[] array = new int[] { 50, 30, 70, 10, 40, 90, 80 };
        BSTree bsTree = bst.CreateBSTree(array);

        bst.LDR_BST(bsTree);

        boolean bool = bst.SearchBSTree(bsTree, 10);
        System.out.println("10是否在二叉排序树中:" + bool);

        BSTree adjustBSTree = bst.DeleteBSTree(bsTree, 50);
        bst.LDR_BST(adjustBSTree);
    }

    // 创建二叉排序树
    public BSTree CreateBSTree(int[] array) {
        BSTree bsTree = null;
        for (int i = 0; i < array.length; i++) {
            if (bsTree == null) {
                bsTree = new BSTree();
                bsTree.data = array[i];
            } else {
                this.InsertBSTree(bsTree, array[i]);
            }
        }
        return bsTree;
    }

    // 递归创建左右子树
    public void InsertBSTree(BSTree bsTree, int key) {
        if (bsTree.data > key) {
            if (bsTree.left == null) {
                bsTree.left = new BSTree();
                bsTree.left.data = key;
            } else {
                InsertBSTree(bsTree.left, key);
            }
        } else {
            if (bsTree.right == null) {
                bsTree.right = new BSTree();
                bsTree.right.data = key;
            } else {
                InsertBSTree(bsTree.right, key);
            }
        }
    }

    // 中序遍历(递归)
    public void LDR_BST(BSTree bsTree) {
        if (bsTree != null) {
            LDR_BST(bsTree.left);
            System.out.println(bsTree.data);
            LDR_BST(bsTree.right);
        }
    }

    // 在二叉排序树中查找元素是否存在
    public boolean SearchBSTree(BSTree bsTree, int key) {
        if (bsTree == null) {
            return false;
        }
        if (bsTree.data == key) {
            return true;
        }
        if (bsTree.data > key) {
            return SearchBSTree(bsTree.left, key);
        } else {
            return SearchBSTree(bsTree.right, key);
        }
    }

    // 删除二叉排序树中的节点
    public BSTree DeleteBSTree(BSTree bsTree, int key) {
        if (bsTree == null) {
            return null;
        }

        if (bsTree.data == key) {
            // 第一种情况：叶子节点
            if (bsTree.left == null && bsTree.right == null) {
                bsTree = null;
            }
            // 第二种情况：节点有左子结点
            if (bsTree.left != null && bsTree.right == null) {
                bsTree = bsTree.left;
            }
            // 第三种情况：节点有右子结点
            if (bsTree.left == null && bsTree.right != null) {
                bsTree = bsTree.right;
            }
            // 第四种情况：节点既有左子结点又有右子结点
            if (bsTree.left != null && bsTree.right != null) {
                BSTree temp = bsTree.right;
                // 查找到右边节点中最左侧的节点
                while (temp.left != null) {
                    temp = temp.left;
                }
                // 将左边节点赋给右边节点中最左侧的节点
                temp.left = bsTree.left;

                bsTree = bsTree.right;
            }

            return bsTree;
        }

        if (bsTree.data > key) {
            bsTree.left = DeleteBSTree(bsTree.left, key);
        } else {
            bsTree.right = DeleteBSTree(bsTree.right, key);
        }

        return bsTree;
    }
}