搜维尔科技：网球运动员使用Xsens寻求精确的动作捕捉

public class MyBinarySearchTree {
    static class Node{
        int val;
        Node left;
        Node right;
        public Node(int val){
            this.val = val;
        }
    }
    // 二叉搜索树 根节点
    Node root = null;
    private int size;


    // 插入数据
    public void put(int val){
        // 查看二叉搜索树是否为空
        // 实例化一个节点
        Node node = new Node(val);
        if(root == null){
            root = node;
            return;
        }
        // 二叉搜索树插入到叶子节点
        Node cur = root;
        Node curFather = null;
        while(cur != null){
            if(val > cur.val){
                curFather = cur;
                cur = cur.right;
            }else if(val < cur.val){
                curFather = cur;
                cur = cur.left;
            }else{
                // 二叉搜索树只用来 查找,
                // 所以遇到相同的值时说明二叉搜索树已经存有,查找时也能查到就无需将重复的数据插入进去了
                System.out.println("二叉搜索树已经存有该数据: "+ val+" 无需继续存储就去");
                return;
            }
        }
        //出了这个循环说明cur已经到了最后null,curFather节点指向二次搜索树叶子节点
        if(val > curFather.val){
            curFather.right = node;
            size++;
        }else{
            curFather.left = node;
            size++;
        }
    }

    // 中序遍历
    private Node inordercur = root;
    public void inorder(Node inordercur){
        if(inordercur == null){
            return;
        }
        inorder(inordercur.left);
        System.out.print(inordercur.val+" ");
        inorder(inordercur.right);
    }


    // 查找二叉搜索树
    public Node find(int val){
        Node cur = root;
//        // 判断根节点是否为空
//        if(cur == null){
//            System.out.println("搜索二叉树节点为空,无法查找");
//            return null;
//        }
        while(cur != null){
            if(val > cur.val){
                cur = cur.right;
            }else if(val < cur.val){
                cur = cur.left;
            }else{
                // 找到相等值
                return cur;
            }
        }
        // 出了此循环说明cur为null,说明查找到数据
        System.out.println("没有查找到: "+ val );
        return null;
    }


    // 查找二叉搜索树方法2
    private Node find2(int val,Node root){
        if(root == null){
            return null;
        }
        if(val == root.val){
            return root;
        }

        Node leftNode = find2(val,root.left);
        if(leftNode != null){
            return leftNode;
        }
        Node rightNode = find2(val,root.right);
        if(rightNode != null){
            return rightNode;
        }
        return null;
    }



    // 删除二叉搜索树
    public void delete(int val){
        if(root == null){
            System.out.println("二叉搜索树为空,无法删除");
            return;
        }

        // 找到要删除的二叉搜索树节点
        Node[] nodeArr = findNode(val);
        // 判断要删除的节点是否为空
        if(nodeArr[0] == null && nodeArr[1] == null){
            System.out.println("要删除节点为空无法删除");
            return;
        }
        Node curFather = nodeArr[0];
        Node deleteCur = nodeArr[1];

        if(deleteCur.left == null){         // 要删除节点 左孩子为空
            // 删除节点为 根节点
            if(deleteCur == root){
//                deleteCur = deleteCur.right;
                root = deleteCur.right;
            // 要删除节点在 删除节点前驱右边
            }else if(curFather.right == deleteCur){
                curFather.right = deleteCur.right;
            // 要删除节点在 删除节点前驱左边
            }else if(curFather.left == deleteCur){
                curFather.left = deleteCur.right;
            }
        }else if(deleteCur.right == null){  // 要删除节点 右孩子为空
            // 删除节点是 根节点
            if(deleteCur == root){
                root = deleteCur.left;
            // 删除节点是 根节点右边
            }else if(curFather.right == deleteCur){
                curFather.right = deleteCur.left;
            }else if(curFather.left == deleteCur){
                curFather.left = deleteCur.left;
            }
        }else{                        // 要删除节点 左右孩子不为空
            // 找要删除节点的 右孩子节点的最左树
            // 也就是比要删除节点大的最小值
            Node cur = deleteCur.right;
            Node lastCur = deleteCur;
            while(cur.left != null){
                lastCur = cur;
                cur = cur.left;
            }
            // 叶子节点覆盖到要删除的 节点
//            deleteCur = cur;
//            root = cur;
            deleteCur.val = cur.val;
            System.out.println("root的数值为: "+root.val);
            if(lastCur.left == cur) {
                lastCur.left = cur.right;
            }else{
                // 要删除节点的 右子树 没有左孩子树
                deleteCur.right = cur.right;
            }
        }
    }

    private Node[] findNode(int val) {
        // cur前驱节点
        Node curFather = null;
        Node cur = root;
        Node[] nodeArr = new Node[2];
        // 找到要删除的二叉搜索树节点
        while(cur != null){
            if(val > cur.val){
                curFather = cur;
                cur = cur.right;
            }else if(val < cur.val){
                curFather = cur;
                cur = cur.left;
            }else{
                // 找到要删除的节点和要删除节点的前驱
                nodeArr[0] = curFather;
                nodeArr[1] = cur;
                break;
            }
        }
        return nodeArr;
    }
}