【BST树】常见笔试题

最新推荐文章于 2022-11-25 09:51:44 发布

成狗先生

最新推荐文章于 2022-11-25 09:51:44 发布

阅读量393

点赞数

分类专栏：高级数据结构文章标签： BST树

本文链接：https://blog.csdn.net/qq_44825669/article/details/94776276

版权

高级数据结构专栏收录该内容

4 篇文章 0 订阅

订阅专栏

（6）判断childTree是否是当前BST树的一颗子树

(7) 根据参数传入的前序遍历结果pre数组和中序遍历结果in数组，重建二叉树

（1）BST树的镜像反转

/**
     * 求BST树的镜像翻转API
     */
    public void mirror(){
        mirror(this.root);
    }

    /**
     * 求BST镜像翻转的递归实现
     * @param root
     */
    private void mirror(BSTNode<T> root) {
        if(root == null){
            return;
        }

        BSTNode<T> tmp = root.getLeft();
        root.setLeft(root.getRight());
        root.setRight(tmp);

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

（2）寻找BST树指定区间的元素结果集

/**
     * 把BST树中，满足[begin，end]区间的所有元素打印出来
     * @param
     * @param end
     */
    public void printAreaDatas(T begin,T end){
        printAreaDatas (this.root,begin,end);
    }
    
    private void printAreaDatas(BSTNode<T> root, T begin, T end) {
        if(root == null){
            return;
        }
        //如果当前节点的值小于begin，就不用再递归节点的左子树了
        if(root.getData ().compareTo (begin) > 0){
            printAreaDatas (root.getLeft (),begin,end);
        }
        //root.getData();
        if(root.getData ().compareTo (end) <= 0
                && root.getData ().compareTo (begin) >= 0){
            System.out.println (root.getData () + " ");
            //当前节点的值小于end，才有必要继续访问当前节点的右子树
            if(root.getData ().compareTo (end) < 0){
                printAreaDatas (root.getRight (),begin,end);
            }
        }
    }

（3）判断一颗二叉树是不是一颗BST树

/**
     * 判断一个二叉树是否是BSt树，是返回true，否则返回false
     */
    public boolean isBSTTree(){
        return isBSTTree (this.root,value);
    }

    private boolean isBSTTree(BSTNode<T> root,T value) {
        if(root == null){
            return true;
        }
        //左子树已经不满足BST树性质了，直接返回，不用继续向下递归了
        if(!isBSTTree (root.getLeft (),value)){
            return false;
        }
        if(value != null){
            if(root.getData ().compareTo (value) < 0){
                return false;
            }
        }
        //注意当前节点判断完后，需要更新下一个value值
        value = root.getData ();
        return isBSTTree (root.getRight (),value);
    }

（4）返回两个节点的最近公共祖先节点

    /**
     * 返回两个节点的最近公共祖先节点
     * @param data
     * @param data2
     * @return
     */
    public T getLCA(T data,T data2){
        return getLCA (this.root,data,data2);
    }

    private T getLCA(BSTNode<T> root, T data, T data2) {
        if(this.root == null){
            return null;
        }
        if(root.getData ().compareTo (data) > 0
                && root.getData ().compareTo (data2) > 0){
            return getLCA (root.getLeft (),data,data2);
        }else if(root.getData ().compareTo (data) < 0
                && root.getData ().compareTo (data2) < 0){
            return getLCA (root.getRight (),data,data2);
        }else{
            return root.getData ();
        }
    }

（5）获取中序遍历倒数第k个节点的值

    /**
     * 中序遍历找第k个节点
     * @param k
     * @return
     */
    public T getOrderValue(int k){
        int num = number (); // num-k   1 2 3 4 5 6 7   k=3 7-3=4
        return getOrderValue (this.root,k);
    }
    private int i = 0;
    private T getOrderValue(BSTNode<T> root, int k) {
        if(root == null){
            return null;
        }
        T val = getOrderValue (root.getLeft (),k);
        if(val != null){
            return val;
        }
        if(i++ == k){
            return root.getData ();
        }
        return getOrderValue (root.getRight (),k);
    }

（6）判断childTree是否是当前BST树的一颗子树

    /**
     * 判断childTree是否是当前BSt树的一颗子树
     */
    public boolean isChildTree(BST<T> tree){
        BSTNode<T> cur = this.root;
        // 在当前BST树上找值为tree.root.getData()的节点
        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());
    }

(7) 根据参数传入的前序遍历结果pre数组和中序遍历结果in数组，重建二叉树

    /**
     * 根据参数传入的pre和in数组，重建二叉树
     * @param pre
     * @param in
     */
    public void rebuild(T[] pre, T[] in) {
        this.root = rebuild (pre,0,pre.length-1, in,0,in.length-1);
    }
    /**
     * pre前序数组的[i,j]数据范围，in中序数组的[m,n]数据范围，
     * 创建一颗二叉树，并把树的根节点进行返回
     * @param pre
     * @param i
     * @param j
     * @param in
     * @param m
     * @param n
     * @return
     */
    private BSTNode<T> rebuild(T[] pre, int i, int j, T[] in, int m, int n) {
        if (i > j || m > n) {
            return null;
        }
        BSTNode<T> node = new BSTNode<> (pre[i], null, null);
        for (int k = m; k <= n; k++) {
            // 在中序数组中找到根节点pre[i]         m, k-1   k+1,n
            if (pre[i].compareTo (in[k]) == 0) {
                node.setLeft (rebuild (pre, i + 1, i + (k - m), in, m, k - 1));
                node.setRight (rebuild (pre, i + (k - m) + 1, j, in, k + 1, n));
                break;
            }
        }
        return node;
    }
}