二叉查找树 中序遍历

 /**
    * 二叉查找树
    */
    public class BinarySortTreeTest {
        // 创建一个节点类 包含值，左节点 右节点
        public class Node {
            int value;
            Node left;
            Node right;

            public Node() {
            }

            // 有参构造
            public Node(int value) {
                this.value = value;
            }

            // 插入节点
            public void add(Node node) {
                // 判断传进来的节点是否为空
                if (node == null) {
                    return;
                }
                // 判断传进来的节点比当前子树的根节点的值大还是小
                // 如果小 这进入左边
                if (node.value < this.value) {
                    // 如果左节点为空 那么传进来的节点就为左节点
                    if (this.left == null) {
                        this.left = node;
                    } else {
                        // 递归在进行判断 ，直到找到为空的节点
                        this.left.add(node);
                    }
                } else {
                    // 如果大于根节点就进入右边
                    // 如果右节点为空,那么传进来的节点就为右节点
                    if (this.right == null) {
                        this.right = node;
                    } else {
                        // 如果右节点不为空 则递归在进行判断
                        this.right.add(node);
                    }
                }
            }

            //中序遍历二叉查找树
            //中序指以升序的方式遍历所有节点 先左节点，在根节点，在右节点
            public void middleOder(Node node) {
                // 如果为空这结束
                if (node == null) {
                    return;
                }
                /*
                先找到最左边的节点 然后输出值 在看其右边是否有值 有则输出
                没有就返回此节点的上一个根节点 输出其值，在看其右节点是否有值，有就输出
                在返回到此节点的上一个根节点
                依次循环
                 */
                middleOder(node.left);

                System.out.println(node.value);

                middleOder(node.right);
            }
            // 查找某一节点 传进来一个值
           public Node serch(int value){
                // 值相等 就返回此对象
                if(this.value == value){
                    return this;
                    // 小于就找此节点的左节点 如果左节点为空 表示没找到
                }else if(value<this.value){
                   if(this.left == null){
                       return null;
                   }else {
                     return   this.left.serch(value);
                   }
                   // 大于就找此节点的右节点 如果右节点为空，表示没找到
               }else {
                    if(this.right ==null){
                        return null;
                    }else {
                        return this.right.serch(value);
                    }

                }
           }

           // 查找父节点
           public Node serchParent(int value){
                // 先判断此节点的左右节点是否与传进来的值相等 相等则此节点就是父节点
               if((this.left != null && this.left.value==value) || (this.right !=null && this.right.value ==value)){
                   return  this;

               } else {
                   // 此节点如果大于传进来的值，则找左节点 左节点为空，表示没有值与其匹配
                   if(value < this.value &&  this.left != null){
                       return this.left.serchParent(value);
                       // 此节点如果大于传进来的值，则找左节点 左节点为空，表示没有值与其匹配
                   }else if(value > this.value && this.right != null){
                       return  this.right.serchParent(value);
                   }
               }
               return null;
           }

        }

        //
        // 插入数据
//    public void insertBST(Key key ,Value val){
//        if(key ==null){
//
//        }
        Node root;
        // 向二叉排序树中添加节点
        public void add(Node node){
            if(root == null){
               root=node;
            }else {
                root.add(node);
            }
//            System.out.println(root.value);
        }
        // 查找二叉排序树的所有节点
        public void frontShow(){
            if(root !=null){
                this.root.middleOder(root);
            }

        }
          // 查找单个节点
        public Node searchNode(int value){
            if(root ==null){
                return null;
            }else {
                return this.root.serch(value);
            }
        }
          // 查找父节点
        public Node searchPanertNode(int value){
            if (root == null){
                return null;
            }else {
                return this.root.serchParent(value);
            }
        }
        // 删除节点
        public void delete(int value){
            if(root ==null){
                return;
            }else {
                // 找到此节点，为空则没有
                Node target=searchNode(value);
                if(target ==null){
                    return;
                }
                // 找到此节点的父节点
                Node parent = searchPanertNode(value);
//                System.out.println(parent.value);
                //要删除的节点是叶子结点
                if(target.left == null && target.right == null){
                    if(parent.left.value == value){
                        // 父节点的子节点改为空才是真的改为空；如把target =null，节点中的值并不会改变
                       parent.left=null;
                    }else {
                        parent.right=null;
                    }
//                  target=null;
//                  Node target1=searchNode(value);
//                  System.out.println("后来的"+target1.value);
                }

                //要删除的节点有两个子节点的情况
                else if (target.left != null && target.right !=null){

                    //删除右子树中值最小的节点，并获取到该节点的值
                    int min=minDelete(target.right);
                    target.value=min;
                }else {

                    //需要删除的目标节点的左节点不为空
                    if(target.left != null){
                        //要删除的子节点是其父节点的左子节点
                        if(parent.left.value == value){
                            parent.left=target.left;
                        }else {
                            //要删除的子节点是其父节点的右子节点
                            parent.right=target.right;
                        }
                    }else {
                        //需要删除的目标节点的右节点不为空
                        if (parent.right!=null){
                            if(parent.left.value == value){
                                parent.left=target.left;
                            }else {
                                parent.right=target.right;
                            }
                        }
                    }
                }

            }
        }
        public int minDelete(Node node){
            while (node.left!=null){
                node=node.left;
            }
            delete(node.value);
            return node.value;
   }
   
        //测试代码
        public static void main(String[] args) {
         
            int[] arr = {7,3,10,12,5,1,9};
            BinarySortTreeTest binary=new BinarySortTreeTest();
           // 添加节点
            for (int i : arr) {

            // 用有参构造创造节点 调用add加入节点
            binary.add(binary.new Node(i));
        }

            // 遍历二叉查找树
            binary.frontShow();
            System.out.println("华丽的分割线");
            // 删除节点 7
            binary.delete(7);
            binary.frontShow();

        // 查找节点 7
          Node node= binary.new Node(7);
          Node res=  binary.searchNode(node.value);
         if(res!=null){
           System.out.println(res.value);
         }else {
              System.out.println("未找到");
          }
       }

    }

积累点滴，做好自己~