二叉搜索树-BSTree

二叉搜索树，即Binary Search Tree.二叉搜索树又叫二叉查找树，或者二叉排序树。

二叉搜索树要求，对于树中每一个节点，都要求左子树每个节点的值都小于当前节点值，右子树的每个节点值都大于当前节点的值。

二叉查找树的查找操作

我们从根节点开始查找，如果当前节点等于我们要查找的数据，那就返回。如果查找的数据比根节点的数据小，那就从左子树中递归查找。如果要查找的数据比根节点的值大，那就在右子树中递归查找。

二叉查找树的插入操作

新插入的数据我们放在叶子节点上，从根节点开始，依次比较插入的数据和节点的大小关系。如果插入的数据比当前节点大，并且当前节点的右子树为空则将新数据直接插入到当前节点的右子节点处。如果不为空则遍历查找右子树查找插入位置。如果插入的数据比当前节点的数据小，并且当前节点的左子树为空则将新数据直接插入到当前节点的左子节点处。如果不为空则遍历查找左子树插入位置。

二叉查找树的删除操作

分三种情况：

①要删除的节点没有子节点，那么我们只需要将父节点中指向这个节点的指针置位null即可。

②要删除的节点只有一个子节点，左子节点或者右子节点。我们只需要将父节点中指向这个节点的指针指向这个节点的子节点。

③删除的节点有两个子节点，则需要找到这个节点右子树中的最小节点，把它替换到要删除的节点上。然后再删除这个最小节点，利用①和②的规则

代码

package com.study.algorithm.tree;

/**
 * @Auther: JeffSheng
 * @Date: 2019/9/2 14:28
 * @Description:
 * 二叉树的增删改查操作
 */
public class BinaryTree {


    /**
     * 在二叉树中查找数据（不考虑重复数据）
     * @param p
     * @param data
     * @return
     */
    public static TreeNode find(TreeNode p,int data){
        while(p!=null){
            if(data < Integer.parseInt(p.data)){
                p = p.left;
            }else if(data > Integer.parseInt(p.data)){
                p = p.right;
            }else{
                return p;
            }
        }
        return null;
    }


    /**
     *在二叉树搜索树中插入一个数据（不考虑重复数据）
     * @param p
     * @param data
     */
   public static void insert(TreeNode p,int data){
        while(p!=null){
            if(data > Integer.parseInt(p.data)){
                if(p.right==null){
                    p.right = new TreeNode(data+"");
                    return;
                }
                p = p.right;
            }else if(data < Integer.parseInt(p.data)){
                if(p.left==null){
                    p.left = new TreeNode(data+"");
                    return;
                }
                p = p.left;
            }
        }
   }


    /**
     * 二叉搜索树的删除操作（不考虑重复数）
     * @param p
     * @param data
     */
   public static void delete(TreeNode p,int data){
       //p节点的父节点
        TreeNode pParent = null;
        while(p!=null && Integer.parseInt(p.data)!=data){
            pParent = p;
            if(data > Integer.parseInt(p.data)){
                p = p.right;
            }else{
                p = p.left;
            }
        }
        //没有找到要删除的节点
        if(p==null){
            return;
        }

        //要删除的节点有两个子节点
        if(p.left!=null && p.right!=null){
           //查找右子树中的最小节点
            TreeNode minNode = p.right;
            //右子树中最小节点的父节点
            TreeNode minParentNode = null;
            while(minNode.left!=null){
                minParentNode = minNode;
                minNode = minNode.left;
            }
            //将右子树中找到的最小节点值替换到p（将要删除的那个节点）中
            p.data = minNode.data;
            //把右子树的那个最小值（没有左子树）删除掉，只需要其父节点的左子节点指向null即可
            p = minNode;
            pParent = minParentNode;
            pParent.left=null;
        }else{
            //删除的节点是叶子节点或者仅有一个子节点
            //待删除节点p的子节点
            TreeNode child = null;
            if(p.left!=null){
                child=p.left;
            }else if(p.right!=null){
                child = p.right;
            }else{
                child=null;
            }

            //待删除节点的父节点空，说明待删除节点时根节点，无父节点
            if(pParent==null){
                p=child;
            }else if(pParent.left==p){
                //待删除节点时其父节点的左子节点，那么将父节点新的'左子节点'(不能是右子节点)指向待删除节点之前的child子节点，因为删除了左子节点必然要补一个左子节点
                pParent.left = child;
            }else{
                //待删除节点时其父节点的右子节点
                pParent.right = child;
            }
        }

   }

    /**
     * 查询二叉搜索树中的最小值
     * @param tree
     * @return
     */
    public TreeNode findMin(TreeNode tree) {
        if (tree == null) {
            return null;
        }
        TreeNode p = tree;
        while (p.left != null) {
            p = p.left;
        }
        return p;
    }

    /**
     * 查询二叉搜索树中的最大值
     * @param tree
     * @return
     */
    public TreeNode findMax(TreeNode tree) {
        if (tree == null) {
            return null;
        }
        TreeNode p = tree;
        while (p.right != null) {
            p = p.right;
        }
        return p;
    }


    public static void main(String[] args) {
        TreeNode root = new TreeNode("33");
        TreeNode a = new TreeNode("16");
        TreeNode b = new TreeNode("50");
        root.left = a;
        root.right = b;
        TreeNode d = new TreeNode("13");
        TreeNode e = new TreeNode("18");
        a.left=d;
        a.right=e;
        TreeNode f = new TreeNode("34");
        TreeNode g = new TreeNode("58");
        b.left=f;
        b.right=g;
        TreeNode h = new TreeNode("15");
        d.right = h;

        TreeNode i = new TreeNode("17");
        TreeNode j = new TreeNode("25");
        e.left = i;
        e.right = j;

        TreeNode k = new TreeNode("19");
        TreeNode l = new TreeNode("27");
        j.left=k;
        j.right=l;
        TreeNode m = new TreeNode("51");
        TreeNode n = new TreeNode("66");
        g.left=m;
        g.right=n;
        TreeNode o = new TreeNode("55");
        m.right=o;
        TreeTraversal.inTraversal(root);

        insert(root,56);
        System.out.println("-------------------------");
        TreeTraversal.inTraversal(root);
        delete(root,55);
        System.out.println("-------------------------");
        TreeTraversal.inTraversal(root);
    }
}