数据结构之二分搜索树增删改查和遍历实现

1. 概念

是指一棵空树或者具有下列性质的二叉树：

1. 若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值；
2. 若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值；
3. 任意节点的左、右子树也分别为二叉查找树；
4. 没有键值相等的节点。

2. 构建一个二分搜素树节点

    public class TreeNode<E extends Comparable<E>>{

        E e;
        TreeNode<E> left;
        TreeNode<E> right;
        public TreeNode(E e){
            this.e = e;
        }
    }

3. 二分搜素树插入节点

向一个二分搜索树b中插入一个节点node的算法，过程为：

1. 若b是空树，则将node所指结点作为根节点插入
2. 若插入的值e等于节点node.e，则不处理
3. 若插入的值e小于节点node.e，则把node所指节点插入到左子树中
4. 若插入的值e大于节点node.e，则把node所指节点插入到右子树中

    public void add(E e){
        root = add(root,e);
    }

    private TreeNode<E> add(TreeNode<E> node,E e){
        if(node == null){
            return new TreeNode<>(e);
        }

        if(e.compareTo(node.e) < 0) {
            node.left = add(node.left, e);
        }else if(e.compareTo(node.e) > 0) {
            node.right = add(node.right, e);
        }
        return node;
    }

4. 二分搜素树查找节点

在二叉搜索树b中查找e的过程为：

1. 若b是空树，则搜索失败，否则：
2. 若e等于b的根节点的数据域之值，则查找成功；否则：
3. 若e小于b的根节点的数据域之值，则查找左子树；否则：
4. 查找右子树。

    1. 查找一个数在不在二分搜索树的节点中

    private boolean find(TreeNode<E> node,E e){
        if(node == null)
            return false;
        if(e.compareTo(node.e) == 0) {
            return true;
        }else if(e.compareTo(node.e) < 0) {
            return find(node.left, e);
        }else{ // (e.compareTo(node.e) > 0)
            return find(node.right, e);
        }
    }


    2. 查找二分搜索树中的最小元素

    //查找最小元素
    public E findMin(){
        TreeNode<E> node = findMin(root);
        return node.e;
    }

    public TreeNode<E> findMin(TreeNode<E> node){
        if(node == null)
            return null;
        //最小元素 肯定在左子树中
        //如果节点没有左子树了，则这个节点就是最小值的节点
        if(node.left == null)
            return node;
        //否则继续查找左子树
        return findMin(node.left);
    }

    3. 查找二分搜索树中的最大元素

    //查找最大元素
    public E findMax(){
        TreeNode<E> node = findMax(root);
        return node.e;
    }

    public TreeNode<E> findMax(TreeNode<E> node){
        if(node == null)
            return null;
        if(node.right == null)
            return node;
        return findMax(node.right);
    }

5. 二分搜素树删除节点

删除节点分三种情况

    1. 删除树中最小元素 递归实现

    /**
     * 删除以node为根的二分搜索树中的最小的节点
     * 返回删除节点后新的二分搜索树的根
     * @param node
     * @return
     */
    private TreeNode<E> removeMin(TreeNode<E> node){

        if(node == null)
            return null;
        //最小值肯定在左子树中，如果当前节点左子树为null，那么该节点就是最小值所在节点
        if(node.left == null) {
            //把当前节点的右子树通过一个局部变量存起来
            TreeNode<E> rightNode = node.right;
            //当前节点右子树置null
            node.right = null;
            size--;
            return rightNode;
        }
        //否则把当前节点的左子树继续复制给节点的left
        node.left = removeMin(node.left);
        return node;
    }

    2. 删除树中最小元素 非递归实现 

    private E removeMinNR(TreeNode<E> root) {
        if(root == null)
            return null;

        TreeNode<E> current = root;
        //记录当前节点的父节点
        TreeNode<E> parent = current;
        //先循环遍历找到最小值所在节点
        while (current.left != null){
            parent = current;
            current = current.left;
        }
        //当前节点的父节点的左还在用当前最小节点的右孩子代替
        parent.left =  current.right;
        return current.e;
    }

    3. 删除树中最大元素 递归实现

    /**
     * 删除以node为根的二分搜索树中的最大的节点
     * 返回删除节点后新的二分搜索树的根
     * @param node
     * @return
     */
    private TreeNode<E> removeMax(TreeNode<E> node){

        if(node == null)
            return null;

        if(node.right == null) {
            TreeNode<E> leftNode = node.left;
            node.left = null;
            size--;
            return leftNode;
        }

        node.right = removeMax(node.right);
        return node;
    }

    4. 删除树中最大元素 非递归实现

     private E removeMaxNR(TreeNode<E> root) {
        if(root == null)
            return null;
        TreeNode<E> current = root;
        TreeNode<E> parent = current;
        while (current.right != null){
            parent = current;
            current = current.right;
        }
        parent.right = current.left;
        return current.e;
    }

    5. 删除树中任意节点 递归实现

    //删除树中的任意元素
    public void remove(E e){
        //这里重新赋值操作不能少 不然删除根节点时会丢数据
        root = remove(root,e);
    }

    /**
     * 删除树中任意元素
     * @param node
     * @param e
     * @return
     */
    private TreeNode<E> remove(TreeNode<E> node,E e){

        if(node == null)
            return null;

        if(e.compareTo(node.e) < 0){
            //如果要删除的值小于根节点的值，则从左子树去中去查找要删除的值
            node.left = remove(node.left,e);
            return node;
        }else if(e.compareTo(node.e) > 0){
            //如果要删除的值大于根节点的值，则从右子树去中去查找要删除的值
            node.right = remove(node.right, e);
            return node;
        }else{
            //找到了要删除的节点
            //如果当前节点左子树为空 逻辑同删除最小节点
            if(node.left == null){
                TreeNode<E> rightNode = node.right;
                node.right = null;
                size--;
                return rightNode;
            }else if(node.right == null){
            //如果当前节点右子树为空 逻辑同删除最大节点
                TreeNode<E> leftNode = node.left;
                node.left = null;
                size--;
                return leftNode;
            }else {
                //左右节点都不为空的情况最复杂

                //1. 查找右子节点的后继节点最小值的节点
                TreeNode<E> successor = findMin(node.right);
                //2. 删除右子树中最小的节点,返回删除节点后新的二分搜索树的根
                successor.right = removeMin(node.right);
                //3. 后继节点的左子树用当前要删除节点的左子树替代
                successor.left = node.left;
                //4. 当前待删除节点左右子树清空 因为用不到了
                node.left = node.right = null;
                //5. 返回这个后继节点
                return successor;
            }
        }
    }

    6. 删除树中任意节点 非递归实现

    /**
     * 删除任意节点非递归实现
     * @param e
     */
    public void removeNR(E e){
        removeNR(root,e);
    }

    private void removeNR(TreeNode<E> node,E e){
        if(node == null) return;
        TreeNode<E> current = node;
        TreeNode<E> parent = node;
        //默认是左孩子
        boolean isLeftChild = true;
        while (current.e != e){
            //记录当前节点
            parent = current;
            if(e.compareTo(current.e) < 0){
                current = current.left;
                isLeftChild = true;
            }else {
                current = current.right;
                isLeftChild = false;
            }

            if(current == null) return;
        }

        //找到了要删除的节点
        if(current.left == null){
            if(current == this.root){
                //如果当前节点是root,则应该把当前节点的右子树赋值给root
                //这么写是错的 root = root.right;
                this.root = current.right;
                current.right = null;
            }else if(isLeftChild){
                TreeNode<E> rChild = current.right;
                current.right = null;
                parent.left = rChild;
                size--;
            }else{
                TreeNode<E> rChild = current.right;
                current.right = null;
                parent.right = rChild;
                size--;
            }
        }else if(current.right == null){
            if(current == this.root){
                //如果当前节点是root,则应该把当前节点的左子树赋值给root
                //这么写是错的 root = root.left;
                this.root = current.left;
                current.left = null;
            }else if(isLeftChild){
                TreeNode<E> lChild = current.left;
                current.left = null;
                parent.left = lChild;
                size--;
            }else{
                TreeNode<E> lChild = current.left;
                current.left = null;
                parent.right = lChild;
                size--;
            }
        }else{
            //左右子树都有的情况
            //查找右子树节点的后继节点最小值的节点
            TreeNode<E> successor = findMin(current.right);
            //删除右子树中最小的节点,返回删除节点后新的二分搜索树的根赋值给后继节点的右子树
            successor.right = removeMin(current.right);
            //后继节点的左子树用当前要删除节点的左子树替代
            successor.left = current.left;
            //当前节点左右子树清空
            current.left = current.right = null;

            if(current == this.root){
                //如果删除的是根节点 需要把这个后继节点重新赋值给root
               this.root = successor;
            }else if(isLeftChild){
                //如果当前要删除的节点是父亲节点的左子树 则parent.left = 后继节点
                parent.left = successor;
            }else{
                // 否则parent.right = 后继节点
                parent.right = successor;
            }
        }
    }

6. 二分搜素树前中后序遍历

    1. 前序遍历 先根节点，再左子树，然后右子树

    //前序遍历
    public void preOrder(){
        System.out.println("前序遍历：");
        preOrder(root);
        System.out.println();
    }

    private void preOrder(TreeNode node){
        if(node == null)
            return;
        System.out.print(node.e+" ");
        preOrder(node.left);
        preOrder(node.right);
    }

    2. 中序遍历 先左子树，再根节点，然后右子树

    //中序遍历
    public void inOrder(){
        System.out.println("中序遍历：");
        inOrder(root);
        System.out.println();
    }

    private void inOrder(TreeNode node){
        if(node == null)
            return;
        inOrder(node.left);
        System.out.print(node.e+" ");
        inOrder(node.right);
    }

    3. 后序遍历 先左子树，再右子树，然后根节点

    //后序遍历
    public void postOrder(){
        System.out.println("后序遍历：");
        postOrder(root);
        System.out.println();
    }

    private void postOrder(TreeNode node){
        if(node == null)
            return;
        postOrder(node.left);
        postOrder(node.right);
        System.out.print(node.e+" ");
    }

7. 二分搜素树非递归前序遍历

    //主要通过栈实现，首先把根节点入栈，然后根节点出栈，
    //然后分别把根节点右子树，左子树入栈，因为先序遍历是先根，再左后右，
    //所以入栈时候应该是先右再左，栈的特点是先进后出，循环条件是栈不为空，
    //首页的节点都出栈后，栈肯定是空的
    private void preOrderNR(TreeNode<E> root){
        if(root == null) return;
        Stack stack = new Stack();
        //入栈
        stack.push(root);
        System.out.println("前序遍历非递归形式：");
        while ( !stack.isEmpty()){
            //出栈
            TreeNode node = (TreeNode) stack.pop();
            if(node == null)    return;
            System.out.print(node.e+" ");
            if(node.right != null) {
                stack.push(node.right);
            }
            if(node.left != null) {
                stack.push(node.left);
            }
        }
    }

8. 二分搜素树层次遍历

    //通过队列实现，队列特点是先进先出，先把根节点入队，然后分别把他的左右子树入队，
    //循环条件是队列不为空，遍历完，队列一定是空的，可以画图理解下
    private void levelOrder(TreeNode node){
        if(node == null)
            return;
        Queue queue = new LinkedList<>();
        //根节点入队
        queue.add(node);
        while (!queue.isEmpty()){
            //出队
            TreeNode tailNode = (TreeNode) queue.remove();
            if(tailNode != null) {
                System.out.print(tailNode.e + " ");
                queue.add(tailNode.left);
                queue.add(tailNode.right);
            }
        }
    }

9.小结和联系方式

主要还是要通过画图和实践才能较好理解二叉排序树

QQ:1509815887