二叉搜索树-删除节点

package binarytree;

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

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

    }
   static class BST{
        Node root;

        //root结点
        public BST(Node root){
                this.root=root;
        }
        //插入操作
        private Node insert(Node node,int data){
             if (null==node){
                 return new Node(data);
             }

             if (node.data>data){
               node.left=insert(node.left,data);
             }else if (node.data<data){
                 node.right=insert(node.right,data);
             }
             return node;
        }

       //插入操作
       public void insert(int data){
            insert(root,data);
       }
    }

    public static void main(String[] args) {
        BST bst = new BST(new Node(1));
        bst.insert(2);

        bst.insert(0);
        bst.insert(4);
        bst.insert(3);
        bst.insert(60);
       preorderTraversal(bst);
       delete(bst,4);
       preorderTraversal(bst);
//       find(bst,4);

    }
    public static  void preorderTraversal(BST bst){
         preorderTraversal(bst.root);
    }
    private static  void preorderTraversal(Node node){
            if (node==null){
                return;
            }
            //先序遍历
            System.out.println(node.data);
            preorderTraversal(node.left);
            preorderTraversal(node.right);
    }

    //查找二叉树指定的数,根据二叉树左子节点小于父节点，和右子节点大于父节点的特性来递归查找
    private static  Node find(Node node,int data){
        if (node.data==data){
            return node;
        }
        if (node.data>data){
           return find(node.left,data);
        }else{
            return find(node.right,data);
        }
    }

    //查找二叉树指定的数,根据二叉树左子节点小于父节点，和右子节点大于父节点的特性来递归查找
    public static  void find(BST bst,int data){
        Node node = find(bst.root, data);
//        System.out.println(node.data);
    }

    public static void delete(BST bst,int data){
            delete(bst.root,data);
    }
    //删除节点
    private static void delete(Node node,int data){
        Node n=node ;
        Node fatherN=null;
        while (n!=null&&n.data!=data){
            fatherN=n;
            if (n.data>data){
               n=n.left;
            }else{
                n=n.right;
            }
        }
        if (null==n){
            return;
        }
        //第一种情况，两边节点都有
        if (n.left!=null&&n.right!=null){
            Node minNumber=n.right;//找出子节点
            Node minNumberFather=n;//找出父节点

            while (minNumber.left!=null){
                minNumberFather=minNumber;
                minNumber=minNumber.left;
            }
//            findMinNumber(minNumberFather,minNumber);
            n.data=minNumber.data;//赋值
            //下面做统一的判断
            n=minNumber;
            fatherN=minNumberFather;
        }

        Node chirld;

        if (n.left!=null){
            chirld=n.left;
            return;
        }else if (n.right!=null){
            chirld=n.right;
        }else {
            chirld=null;
        }

        if (fatherN.left==n){
            fatherN.left=chirld;
        }else if (fatherN.right==n){
            fatherN.right=chirld;
        }else{
            node=chirld;
        }

    }

     
}

删除二叉树的节点代码，拉出来分析

 //删除节点
    private static void delete(Node node,int data){
        Node n=node ;
        Node fatherN=null;
        //找找要删除的节点和它的父节点
        while (n!=null&&n.data!=data){
            fatherN=n;
            if (n.data>data){
               n=n.left;
            }else{
                n=n.right;
            }
        }
        if (null==n){
            return;
        }
        //第一种情况，两边节点都有
        if (n.left!=null&&n.right!=null){
            Node minNumber=n.right;//找出子节点
            Node minNumberFather=n;//找出父节点
            //这里为什么只遍历左边的节点，因为二叉树左边的节点都比右边的小特性，也是找出父子节点
            while (minNumber.left!=null){
                minNumberFather=minNumber;
                minNumber=minNumber.left;
            }
            //给要删除的节点赋值，这种情况下相当于删除了节点，但是没有删除右边最小节点
            n.data=minNumber.data;//赋值
            //下面做统一的判断
            n=minNumber;//把右边最小节点赋值给n
            fatherN=minNumberFather;//把右边最小节点的父节点赋值给fatherN
        }
        //下面公共代码用于移动节点位置
        //如果要删除的节点只有左节点或者只有右节点或者没有，
        //上面  n=minNumber;
        //    fatherN=minNumberFather;  这两个的赋值在这里也同样适用，
        //所以用公共代码，这种情况有可能存在右节点，但是不可能存在左节点（
        //因为已经左边已经是最小节点了）。
        Node chirld;
        if (n.left!=null){
            chirld=n.left;
        }else if (n.right!=null){
            chirld=n.right;
        }else {
            chirld=null;
        }
        //用父节点的左右子节点来进行判断，然后赋值，直接替换掉对象里面的索引
        if (fatherN.left==n){
            fatherN.left=chirld;
        }else if (fatherN.right==n){
            fatherN.right=chirld;
        }else{
            node=chirld;
        }

    }

代码很巧妙