二叉排序树BST(java)

问题描述：
构建一颗BST，对其实现节点插入、删除、各种遍历、查找、前驱和后驱的查找、叶子节点个数、判断二叉树是否相同、判断是否为完全二叉树、求其树的最大值和最小值。
代码如下：
树的节点定义如下：

public class BstNode {
    //二叉排序树的节点
    int data;
    BstNode parent;//双亲节点
    BstNode left;//左孩子
    BstNode right;//有孩子
    public BstNode(int data) {//构造器
        this.data = data;
    }
}

实现类如下：

import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class MyBst {
    BstNode root;//根节点
    int size;//记录节点的个数
    public MyBst(BstNode root) {
        this.root = root;
        size++;
    }
    public void insert(int x){//二叉排序树中插入新节点
        BstNode p=root;
        BstNode pre=null;//记录p节点的父节点
        while (p!=null){//找到新加入的节点应该插入的位置
           pre=p;
           if (x>p.data){//数据大于当前节点
               p=p.right;
           }else if (x<p.data){//数据小于当前节点
               p=p.left;
           }else {//数据相等的情况时直接return
               return;
           }
        }
        p=new BstNode(x);
        p.parent=pre;
        if (x>pre.data){
            pre.right=p;
        }else pre.left=p;
        size++;
    }

    public int getHeight(BstNode x){//获取当前节点的高度
        if (x==null) return 0;
        return 1+Math.max(getHeight(x.left),getHeight(x.right));
    }
  // List<Integer> list=new LinkedList<>(); //写成静态不利于后期查询
    public List<Integer> inOrder(BstNode root, List<Integer> list){
        if (root==null) return list;
        inOrder(root.left,list);
        list.add(root.data);
        inOrder(root.right,list);
        return list;
    }
    //查找元素 判断x元素是否存在
    public BstNode lookElement(int x){
        BstNode p=root;
        while (p!=null) {
            if (p.data > x) {
                p = p.left;
            } else if (p.data < x) {
                p = p.right;
            } else return p;
        }
        return null;
    }

    public int max(){//寻找二叉树最大值
        BstNode p=root;
        while (p.right!=null){
            p=p.right;
        }
        return p.data;
    }

    public int min(){//寻找二叉树最小值
        BstNode p=root;
        while (p.left!=null){
            p=p.left;
        }
        return p.data;
    }

    public BstNode getMin(BstNode x){//寻找二叉树的某一子树的最小值
        BstNode p=x;
        while (p.left!=null){
            p=p.left;
        }
        return p;
    }

    public void remove(int x){//删除二叉树的某一节点
        BstNode p=lookElement(x);
        if (p!=null){
            if (p.left==null&&p.right==null){//如果是叶子节点，可以直接去掉
                if (p.parent==null){//说明只有一个根节点
                    root=null;
                    return;
                }
                BstNode parent=p.parent;
                if (parent.data>x){//判断他是节点的左右孩子
                    parent.left=null;
                }else parent.right=null;
                p.parent=null;
                p=null;
            }else if(p.left==null){//待删除的节点为单支节点 右子不为空
                BstNode parent=p.parent;
                BstNode right=p.right;
                if (parent==null){//若为根节点
                    root=right;
                    return;
                }
                right.parent=parent;
                if (parent.data>p.data){//p为左子树
                    parent.left=right;
                }else {
                    parent.right=right;
                }
                p=null;
            }else if (p.right==null){//待删除的节点为单支节点 左子不为空
                BstNode parent=p.parent;
                BstNode left=p.left;
                if (parent==null){//若为根节点
                    root=left;
                    return;
                }
                if (parent.data>p.data){//p为左子树
                    parent.left=left;
                }else {
                    parent.right=left;
                }
                left.parent=parent;
                p=null;
            }else {//否则为双端都有节点 则可以找到右子树的最小值，将其值赋值给待删除的节点，然后删除最小值即可
                BstNode min=getMin(p.right);
                int data=p.data;
                int target=min.data;
                p.data=target;
                min.data=data;
                remove(data);//相当于递归删除右子树的最小的节点
            }
            size--;
        }
    }
    //判断当前节点为左子树还是右子树
    public String isLeft(BstNode x){
        BstNode p=x.parent;
        if (p!=null){
            if (x.data>p.data) return "right";
            else return "left";
        }else return "";
    }
    //寻找某一结点的前驱
    public int predecessor(int x){
        BstNode p=lookElement(x);
        if (p!=null){
            if (p.left!=null) return p.left.data;
            else {
                BstNode p1=p;
                BstNode p2=p.parent;
                while (p2!=null&&isLeft(p1).equals("left")){//寻找第一个为右孩子的节点
                    p1=p2;
                    p2=p2.parent;
                }
                return p2==null?-10000:p2.data;
            }
        }else return -10000;//表示没有后继
    }
    //寻找某一结点的后继
    public int successor(int x){
        BstNode p=lookElement(x);
        if (p!=null){
            if (p.right!=null) return p.right.data;
            else {
                BstNode p1=p;
                BstNode p2=p.parent;
                while (p2!=null&&isLeft(p1).equals("right")){//寻找第一个为左孩子的节点
                    p1=p2;
                    p2=p2.parent;
                }
                return p2==null?-10000:p2.data;
            }
        }else return -10000;//表示没有前驱
    }
   //层序遍历
    public List<Integer> levelOrder(BstNode root){
        Queue<BstNode> queue=new LinkedList<>();
        List<Integer> list=new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()){
            BstNode p=queue.poll();
            list.add(p.data);
            if (p.left!=null)  queue.add(p.left);
            if (p.right!=null) queue.add(p.right);
        }
       return list;
    }
    //层序遍历2
    public List<List<Integer>> levelOrder1(BstNode root){
        Queue<BstNode> queue=new LinkedList<>();
        List<List<Integer>> list=new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()){
            int size=queue.size();//记录当前层的元素个数
            List<Integer> list1=new LinkedList<>();
            while (size>0){
                BstNode p=queue.poll();
                list1.add(p.data);
                if (p.left!=null)  queue.offer(p.left);
                if (p.right!=null) queue.offer(p.right);
                size--;
            }
            list.add(list1);
        }
        return list;
    }
   //求叶子节点的个数
    public int getLeaf(BstNode root){
        if (root==null) return 0;
        if (root.left==null&&root.right==null) return 1;//递归出口
        return getLeaf(root.left)+getLeaf(root.right);

    }
    //判断一棵树为完全二叉树
    public boolean isallBst(BstNode root){
            //层序遍历
        if (root==null) return true;
            Queue<BstNode> queue=new LinkedList<>();
            List<BstNode> list=new LinkedList<>();
            queue.add(root);
            while (!queue.isEmpty()){
                BstNode p=queue.poll();
                list.add(p);
                if (p.left!=null)  queue.add(p.left);
                if (p.right!=null) queue.add(p.right);
            }
            int target=-1;
        for (int i = 0; i <list.size() ; i++) {
            if (list.get(i).left==null&&list.get(i).right!=null)return false;
            else if (list.get(i).left!=null&&list.get(i).right==null){//找到第一个右子树为空，而左子树不为空的下标元素
                target=i+1;
                break;
            }
        }
        //target之后的节点必须都是叶子节点，即为完全二叉树
        for (int i = target; i <list.size() ; i++) {
            if (list.get(i).right!=null||list.get(i).left!=null) return false;
        }
        return true;
    }
    //判断两颗二叉树是否完全相同
    public boolean isSame(BstNode x,BstNode y){
        if (x==null&&y==null)return true;//两个都为空，说明走到了尽头 放回true
        if (x!=null&&y==null) return false;
        if (x==null&&y!=null) return false;
        if (x.data!=y.data) return false;//数据不相等，返回false
        return isSame(x.left,y.left)&&isSame(x.right,y.right);
    }
}

测试如下：

import java.util.LinkedList;
import java.util.List;
public class Test {
    public static void main(String[] args) {
        BstNode root=new BstNode(5);
        MyBst myBst=new MyBst(root);
        myBst.insert(3);
        myBst.insert(6);
        myBst.insert(7);
        myBst.insert(10);
        myBst.insert(8);
        myBst.insert(0);
        myBst.insert(4);
        int size=myBst.size;
        int height=myBst.getHeight(root);
        System.out.println(size);
        System.out.println(height);
//        List<Integer> list=myBst.inOrder(root);
//        System.out.println(list.toString());
       // myBst.remove(4);
      //  myBst.remove(10);
        List<Integer> list1=new LinkedList<>();
        myBst.inOrder(root,list1);
        System.out.println("-----------"+list1.toString());
        System.out.println(myBst.predecessor(8));
        List<List<Integer>> list=myBst.levelOrder1(root);
        System.out.println(list.toString()+"----------");
        System.out.println(myBst.getLeaf(root));
        System.out.println(myBst.isallBst(root));
        BstNode root1=new BstNode(5);
        MyBst myBst1=new MyBst(root1);
        myBst1.insert(3);
        myBst1.insert(6);
        myBst1.insert(7);
        myBst1.insert(10);
        myBst1.insert(8);
        myBst1.insert(0);
        myBst1.insert(4);
        System.out.println(myBst1.isSame(root,root1));
    }
}

结果如下：