数据结构及算法 | Java数据结构——BST二叉搜索树(下)

上次关于BST二叉搜索树的部分还遗留有一些扩展型的问题，以及增加、删除、查找元素的递归实现，此篇作为补充。

一、必备基础操作的实现

1、BST树的插入元素的递归实现

/**
 *  BST树的递归插入API接口
 */
private void insert(T data){
    this.root = insert(data,root);
}
//递归实现的过程
private BSTNode<T> insert(T data, BSTNode<T> root) {
    if(root == null){//树原本为空的话，直接新建root节点插入第一个值
        return new BSTNode<>(data,null,null);//左右孩子为空
    }
    if(root.getData().compareTo(data) > 0){//插入值小于根节点，往左孩子区域找合适位置
        insert(data,root.getLeft());
    }else if(root.getData().compareTo(data) < 0){
        insert(data,root.getRight());
    }else{
        ;
    }
    return root;
}

2、BST树的删除元素的递归实现

/**
 * BST树的删除元素API接口
 */
private void remove(T data){
    this.root = remove(root,data);
}
//删除操作的递归实现
private BSTNode<T> remove(BSTNode<T> root, T data){
    if(root == null){//根节点为null,没有元素可删除
        return null;
    }
    if(root.getData().compareTo(data) > 0){//data小于根节点值
        root.setLeft(remove(root.getLeft(),data));
    }else if(root.getData().compareTo(data) < 0){
        root.setRight(remove(root.getRight(),data));
    }else{
        if(root.getLeft() != null && root.getRight() != null){
            BSTNode<T> old = root;
            root = root.getLeft();//左子树的右孩子
            while(root.getRight() != null){
                root = root.getRight();//直到找到前驱结点
            }
            root.setData(root.getData());
            root.setLeft(remove(root.getLeft(),root.getData()));
        }else if(root.getLeft() == null){
            return root.getLeft();
        }else if(root.getRight() == null){
            return root.getRight();
        }else{
            return null;
        }
    }
    return root;
}

3、BST树的查找元素递归实现

/**
 * 递归实现查找有无data元素的API接口
 */
private boolean query(T data){
    return query(root,data);
}
//查找的递归实现过程
private boolean query(BSTNode<T> root, T data) {
    if(root == null){
        return false;
    }
    if(root.getData().compareTo(data) > 0){
        query(root.getLeft(),data);
    }else if(root.getData().compareTo(data) < 0){
        query(root.getRight(),data);
    }else{//data==root.getData();
        return true;
    }
    return false;//找一遍都没找到，返回false
}

二、扩展问题

1、以root为根节点，计算BST树的节点个数

/**
 * 引出问题1：以root为根节点，计算BST树的节点个数
 */
private int number(BSTNode<T> root){
    if(root == null){
        return 0;
    }else{
        return number(root.getLeft())+number(root.getRight()) + 1;
    }
}

2、返回BST树的高度（层数）

/**
 * 引出问题2：返回BST树的高度（层数）
 */
private int level(){
    return level(this.root);
}
//返回高度的递归实现过程
private int level(BSTNode<T> root) {
    if(root == null){
        return 0;
    }else{
        int left = level(root.getLeft());
        int right = level(root.getRight());
        return left > right ? left+1:right+1;
    }
}

3、BST树的镜像翻转API接口

/**
 * 引出问题3：BST树的镜像翻转API接口
 */
private void mirror(){
    mirror(this.root);
}
//镜像的实现过程
private void mirror(BSTNode<T> root) {
    if(root == null){
        return;
    }
    BSTNode<T> temp = root.getLeft();
    root.setLeft(root.getRight());
    root.setRight(root.getLeft());

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

4、打印BST树中[begin,end]区间内的所有元素

/**
 * 引出问题4：打印BST树中[begin,end]区间内的所有元素
 */
private void printAreaData(T begin,T end){
    printAreaData(root,begin,end);
    System.out.println();
}
//打印区间内元素的递归实现过程
private void printAreaData(BSTNode<T> root, T begin, T end){
    if(root == null){
        return;
    }
    if(root.getData().compareTo(begin) > 0){//begin仍然小于当前节点，继续往左孩子寻找
        printAreaData(root.getLeft(),begin,end);
    }
    if(root.getData().compareTo(end) < 0){//end仍大于当前节点的值，往右孩子寻找
        printAreaData(root.getRight(),begin,end);
    }
    if(root.getData().compareTo(begin) >= 0 && root.getData().compareTo(end) <= 0){
        System.out.println(root.getData() + "  ");//在[begin，end]区间上打印这个节点
    }
}

5、判断二叉树是否为BST树，是返回true，不是返回false

/**
 * 引出问题5：判断二叉树是否为BST树，是返回true，不是返回false
 */
private boolean isBST(){
    T val = null;
    return isBST(root,val);
}
private boolean isBST(BSTNode<T> root, T val) {
    if(root == null){
        return true;
    }
    if(!isBST(root.getLeft(),val)){//左子树不满足条了，直接返回，不再向下判断
        return false;
    }
    if(val != null && val.compareTo(root.getData()) > 0){//val大于当前节点的值
        return false;
    }
    val = root.getData();//判断完成后更新一下当前val值
    return isBST(root,val);
}
private boolean isBSTree(BSTNode<T> root) {
    if (root == null) {
        return true;
    }

    if (root.getLeft() != null
            && root.getLeft().getData().compareTo(root.getData()) > 0) {
        return false;
    }
    if (root.getRight() != null
            && root.getData().compareTo(root.getRight().getData()) > 0) {
        return false;
    }
    return isBSTree(root.getLeft()) && isBSTree(root.getRight());
}

6、返回两个节点最近公共祖先节点

/**
 * 引出问题6：返回两个节点最近公共祖先节点
 */
private T getFather(T data1,T data2){
    return getFather(root,data1,data2);
}
//递归实现过程
private T getFather(BSTNode<T> root, T data1, T data2) {
    if (root == null) {
        return null;
    }
    //如果当前节点值大于数值1和数值2，则往当前节点左孩子节点方向找
    if (root.getData().compareTo(data1) > 0 && root.getData().compareTo(data2) > 0) {
        return getFather(root.getLeft(), data1, data2) ;
    } else if (root.getData().compareTo(data1) < 0 && root.getData().compareTo(data2) < 0) {
        return getFather(root.getRight(), data1, data2) ;
    } else {
        return root.getData();
    }
}

7、返回中序遍历倒数第K个节点的值

/**
 * 引出问题7：返回中序遍历倒数第K个节点的值
 */
public T getOrderValue(int k){
    return getOrderValue(this.root,k);
}
private int i = 1;
private T getOrderValue(BSTNode<T> root, int k) {
    if(root == null){
        return null;
    }
    T val = getOrderValue(root.getRight(),k);
    if(val != null){
        return val;
    }
    if(i++ == k){
        return root.getData();
    }
    return getOrderValue(root.getLeft(),k);
}

8、判断一棵树是否为BST树的子树的API接口

/**
 * 引出问题8：判断一棵树是否为BST树的子树的API接口
 */
public boolean isChildTree(BST<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> cur, BSTNode<T> root) {
    if(cur == null && root == null){
        return true;
    }
    if(cur == null){//BST树节点少于tree的节点，说明不是子树
        return false;
    }
    if(root == null){//tree节点遍历完了，说明节点都在BST树的对应位置
        return true;
    }
    if(cur.getData() != root.getData()){
        return false;
    }
    return isChildTree(cur.getLeft(),root.getLeft()) && isChildTree(cur.getRight(),root.getRight());
}

9、根据传入的前序遍历和中序遍历数组，重建BST树

/**
 * 引出问题9：根据传入的前序遍历和中序遍历数组，重建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(i > j || m > n){
        return null;
    }
    BSTNode<T> node = new BSTNode<>(pre[i],null,null);
    for(int k = m;k < n;k++){
        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;
}

挣扎了一上午的代码实现，应该算是比较全的了吧>_<