Java实现二叉查找树（插入、查找、遍历、删除）

class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode parent;
    public TreeNode(int val) {
        this.val = val;
    }
}

class BSTree{
    TreeNode root;

    public BSTree(TreeNode root) {
        this.root = root;
    }

    public TreeNode getRoot() {
        return root;
    }

    public void setRoot(TreeNode root) {
        this.root = root;
    }

    /**
     * 插入递归
     */
    public TreeNode insertNode(TreeNode root, TreeNode t){
        if(root == null) {
            root = t;
        }
        else if(root.val < t.val) {
            TreeNode rgt = insertNode(root.right,t);
            root.right = rgt;
            rgt.parent = root;
        }
        else if(root.val > t.val) {
            TreeNode ltf = insertNode(root.left,t);
            root.left = ltf;
            ltf.parent = root;
        }
        return root;
    }

    /**
     * 查找--递归
     *
     */
    public  TreeNode searchNode(TreeNode root,int x){
        if(root == null) {
            return null;
        }
        else if(root.val > x){
            return searchNode(root.left,x);
        }
        else if(root.val < x){
            return searchNode(root.right,x);
        }
        else {
            return root;
        }
    }
    /**
     * 中序遍历-递归
     */
    public  void inOrder(TreeNode root){
        if(root!=null){
            inOrder(root.left);
            System.out.print(root.val+" ");
            inOrder(root.right);
        }
    }

    /**
     * 找到节点的后继节点
     */
    private TreeNode getSuccessorNode(TreeNode node){
        TreeNode target = node.right;
        if(target == null) {
            return null;
        }else{
            while(target.left != null){
                target = target.left;
            }
        }
        return target;
    }

    /**
     * 删除值为x的节点
     * 1、删除的节点是叶子节点
     * 2、删除的节点仅有左子树或右子树
     * 3、删除的节点既有左子树又有右子树
     *
     */
    public void delete(TreeNode root,int x){
        if(root==null){
            return ;
        }
        TreeNode t = root,pnt = null;
        //找到这个节点
        t = searchNode(root,x);
        if(t == null) {
            return ;
        }
        pnt = t.parent;
        if(t.left == null && t.right == null){ //节点是叶子节点
            if(t == root) { //节点是根节点
                root = null;
            }else{
                if(pnt.left == t){ //节点是父节点的左孩子
                    pnt.left = null;
                }else{//节点是父节点的右孩子
                    pnt.right = null;
                }
            }
        }
        else if(t.left != null && t.right == null){ //待删除的节点只有左孩子
            if(t == root){
                root = t.left;
            }else{
                if(pnt.left == t){
                    pnt.left = t.left;
                }else{
                    pnt.right = t.left;
                }
            }
        }
        else if(t.left == null && t.right != null){//待删除的节点只有右孩子
            if(t == root){
                root = t.right;
            }else{
                if(pnt.left == t){
                    pnt.left = t.right;
                }else{
                    pnt.right = t.right;
                }
            }
        }
        else{ //待删除的节点既有左孩子又有右孩子
            TreeNode successor = getSuccessorNode(t);
            //后继节点的值赋给待删除节点，然后删除后继节点
            t.val = successor.val;
            //后继节点的左孩子为空
            TreeNode pntOfSuccessor = successor.parent;
            if(pntOfSuccessor == t){
                t.right = successor.right;
            }else{
                pntOfSuccessor.left = successor.right;
            }
        }
    }
}

public class BSTTest {

    public static void main(String[] args){
          int[] nodeVal = {10,30,8,12,5,9,15,14,17,25,36,32,31,34};
          BSTree bsTree = new BSTree(new TreeNode(20));
          TreeNode root = bsTree.getRoot();
          for(int i=0;i<nodeVal.length;i++){
              if(bsTree.searchNode(root,nodeVal[i]) == null){
                  bsTree.insertNode(root,new TreeNode(nodeVal[i]));
              }
          }
          bsTree.inOrder(root);
          System.out.println("\n删除节点9");
          bsTree.delete(root,9);
          bsTree.inOrder(root);
          System.out.println("\n删除节点12");
          bsTree.delete(root,12);
          bsTree.inOrder(root);
          System.out.println("\n删除节点36");
          bsTree.delete(root,36);
          bsTree.inOrder(root);
          System.out.println("\n删除节点10");
          bsTree.delete(root,10);
          bsTree.inOrder(root);
    }
}