高级数据结构之BST（二）

1、求BST树的镜像

    /*
    求BST树的镜像
     */
    public void mirror(){
        mirror(this.root);
    }
    private void mirror(BinNode<T> root){
        if(root==null){
            return;
        }
            BinNode<T> temp = root.getLeft();
            root.setLeft(root.getRight());
            root.setRight(temp);

            mirror(root.getLeft());
            mirror(root.getRight());
    }
}

2、将满足[begin，end]区间的元素打印出来

     /*
    把BST树中满足[begin,end]区间的元素打印出来
     */
    public void findAreaData(T begin, T end) {
        findAreaData(this.root, begin, end);
    }
    private void findAreaData(BSTNode<T> root, T begin, T end) {
        if (root == null) {
            return;
        }
        if (root.getData().compareTo(begin) > 0) {//优化二叉树遍历
            findAreaData(root.getLeft(), begin, end);
        }
        if (root.getData().compareTo(begin) >= 0
                && root.getData().compareTo(end) <= 0) {
            System.out.print(root.getData() + "  ");
        }
        if (root.getData().compareTo(end) < 0) {//优化二叉树遍历
            findAreaData(root.getRight(), begin, end);
        }
    }

3、判断一棵树是不是BST树

BST树特点就是：左孩子节点的值小于根节点，右孩子节点的值大于根节点

     /*
    判断一颗二叉树是否是BST树
     */
    public boolean isBSTree() {
        T value = null;
        return isBSTree(this.root, value);
    }

    private boolean isBSTree(BSTNode<T> root, T value) {
        if (root == null) {
            return true;
        }
        //左子树不是BST树直接返回
        if (!isBSTree(root.getLeft(), value)) {
            return false;
        }
        //不满足升序
        if (value != null && root.getData().compareTo(value) < 0) {
            return false;
        }
        value = root.getData();
        return isBSTree(root.getRight(), value);
    }

4、求data1和data2最近的公共祖先节点

     /*
    求data1和data2的最近公共祖先结点
     */
    public T getLCA(T data1, T data2) {
        //判断data1和data2是否存在
        if(!non_query(data1) || !non_query(data2)){
            return null;
        }
        return getLCA(this.root, data1, data2);
    }

    private T getLCA(BSTNode<T> root, T data1, T data2) {
        if (root == null) {
            return null;
        }
        if (root.getData().compareTo(data1) < 0
                && root.getData().compareTo(data2) < 0) {//往右子树搜索
            root = root.getRight();
            return getLCA(root, data1, data2);
        } else if (root.getData().compareTo(data1) > 0
                && root.getData().compareTo(data2) > 0) {//往左子树搜索
            root = root.getLeft();
            return getLCA(root, data1, data2);
        }
            return root.getData();
    }

5、判断参数tree是不是当前BST树的一颗子树

     /*
    判断参数tree是不是当前BST树的一颗子树
     */
    public boolean isChildTree(BSTree<T> tree){
        BSTNode<T> cur=this.root;
        while (cur!=null){
            if(cur.getData().compareTo(tree.root.getData())>0){
                cur=cur.getLeft();
            }else if(cur.getData().compareTo(tree.root.getData())<0){
                cur=cur.getRight();
            }else{
                break;
            }
        }
        if(cur==null){
            return false;
        }
        return isChildTree(cur,tree.root);
    }

    private boolean isChildTree(BSTNode<T> f, BSTNode<T> c) {
        if(f==null && c==null){
            return true;
        }
        if(f==null){
            return false;
        }
        if(c==null){
            return true;
        }
        if(f.getData().compareTo(c.getData())!=0){
            return false;
        }
        return isChildTree(f.getLeft(),c.getLeft())&&isChildTree(f.getRight(),c.getRight());
    }

6、根据BST树的前序和中序遍历结果重建二叉树

     /*
    根据BST树的前序和中序重建二叉树
     */
    public void rebuild(T[] pre, T[] in) {
        this.root = rebuild(pre, 0, pre.length-1, in, 0, in.length-1);
    }
    private BSTNode<T> rebuild(T[] pre, int i, int j,
                               T[] in, int m, int n) {
        if(j!=n){
            return null;
        }
        if(i>j||m>n){
            return null;
        }
        //首先拿前序遍历的第一个结点生成根节点
        BSTNode<T> root=new BSTNode<T>(pre[i],null,null);

        for(int k=m;k<=n;++k){//在中序遍历中搜索，找到根节点对应的位置
            if(in[k].compareTo(pre[i])==0){
                root.setLeft(rebuild(pre,i+1,i+(k-m),in,m,k-1));
                root.setRight(rebuild(pre,i+(k-m)+1,j,in,k+1,n));
                break;
            }
        }
        return root;
    }

7、判断BST是否为AVL树

只要左右子树的高度差不超过1就是AVL树

     /*
    判断BST树是否为AVL树   只要节点的左右子树的高度差不超过1就是AVL树
     */
    public boolean isAVLTree(){
        int l=isAVLTree(this.root);
        return l!=-1;
    }
    private int isAVLTree(BSTNode<T> root) {
        if(root==null){
            return 0;
        }else{
            int left=isAVLTree(root.getLeft());
            int right=isAVLTree(root.getRight());
            if(left==-1 || right==-1 || Math.abs(left-right)>1){
                return -1;
            }
            return left>right?left+1:right+1;
        }
}