Java-高级数据结构-BST树的概念、以及它的插入、删除操作的实现

**

一、什么是BST树？

BST：
每个节点最多有两个孩子：右孩子》父节点的值》左孩子 即为 BST树 Binary search Tree 二叉搜索树
示意图如下：

如图所示：58为根节点（root），23是它的左孩子，82是它的右孩子，左孩子比58小，右孩子比58大，其他节点同理，23的左孩子为12，右孩子为35。

标题二、BST树节点的实现

/**
 * BST树的节点类型
 */
  class BSTNode<T extends Comparable<T>>{
      private T data;
      private BSTNode<T> left;
      private BSTNode<T> right;

      public BSTNode(T data){
          this(data,null,null);
      }

    public BSTNode(T data, BSTNode<T> left, BSTNode<T> right) {
        this.data = data;
        this.left = left;
        this.right = right;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public BSTNode<T> getLeft() {
        return left;
    }

    public void setLeft(BSTNode<T> left) {
        this.left = left;
    }

    public BSTNode<T> getRight() {
        return right;
    }

    public void setRight(BSTNode<T> right) {
        this.right = right;
    }
}

三、BST树的实现

/*
  BST树的实现
 */
   class BST<T extends Comparable<T>>{
       private BSTNode<T> root;  //指向BST树的根节点
       public BST(){
          this.root = null; //默认根节点为空
       }
}

四、BST树的非递归插入

 /*
    BST树的非递归插入
    */
    public void insert(T data){
       //如果root为空
        if (this.root == null){
            //如果root为空，则生成新节点，用root指向
            this.root = new BSTNode<T>(data);
            return;
        }
        BSTNode<T> parent = null; //定义一个指针指向父节点
        BSTNode<T> cur = this.root; //定义一个指针指向根节点
        while (cur != null){
            //当根节点不为空时
            parent = cur;
            if (cur.getData().compareTo(data)>0){
               cur = cur.getLeft();
            } else if (cur.getData().compareTo(data)<0){
               cur = cur.getRight();  
            } else {
                return;
            }
        }
        if (parent.getData().compareTo(data)>0){
            parent.setLeft(new BSTNode<T>(data));
        } else {
            parent.setRight(new BSTNode<T>(data));
        }

    }

五、BST树的非递归删除操作

/*
        BST树的非递归删除
    */
    public void remove(T data){
        BSTNode<T> parent = null;
        BSTNode<T> cur = root;

        while (cur!= null){
            if (cur.getData().compareTo(data)>0){
                parent = cur;
                cur = cur.getLeft();
            } else if (cur.getData().compareTo(data)<0){
                parent = cur;
                cur = cur.getLeft();
            } else {
                break;
            }
        }
        if (null == cur){
            return;
        }
        if (cur.getLeft()!=null && cur.getRight()!=null){
            //用前驱节点代替删除结点，然后删除前驱结点
            //前驱节点：待删除节点左子树中，值最大的节点
            //后驱节点：待删除节点右子树中，值最小的节点
            BSTNode<T> old = cur;
            parent = cur;
            cur = cur.getLeft();
            while (cur.getRight() != null){
                parent = cur;
                cur = cur.getRight();
            }
            old.setData(cur.getData());
        }
        //删除cur节点
        BSTNode<T> child = cur.getLeft();
        if (child != null){
            child = cur.getRight();
        }
        if (parent == null){
            this.root =child;
        } else if (parent.getLeft() == cur){
            parent.setLeft(child);
        } else {
            parent.setRight(child);
        }
    }