高级数据结构---二叉查找树及其增删改查实现

二叉树查找树：

二叉查找树也叫二叉搜索树，二叉排序树。它也是一种特殊的二叉树，

它具有以下特点

1.如果它的左子树不为空，则左子树上结点的值都小于根结点。

2.如果它的右子树不为空，则右子树上结点的值都大于根结点。

3.子树的子树同样也要遵循以上两点

 

为什么又叫做二叉排序树，因为具有这种特殊特点的二叉树，它的中序遍历一定是有序的，如下：

中序遍历的结果是0,1,3,4,5,7,8,9,10

推荐一个网站：https://www.cs.usfca.edu/~galles/visualization/Algorithms.html 这个上面有各种数据结构的操作，之前在mysql索引数据结构这篇文章中也推荐过。

插入的时候每次都是和根结点或者子树的根结点比较，大于走右边，小于走左边，直到找到它应该插入的位置。新元素插入的位置肯定值在叶子结点。其实它的插入就是一次查找。每次判断之后就会折半，所以说它的查询效率是O(logn)。

查询和插入的时候类似，修改就没什么好说的了，直接把数据覆盖上去即可

重点说下二叉查找树的删除。

它的删除分三种情况：

1.删除的是叶子结点数据，可以看出来，直接删除就可以了，比如上面0,4,7,10，将其双亲的对应子树指向null即可

2.删除的是度为1的结点，比如上面的1,9，只需要将它的子树的根结点覆盖当前删除的这个节点即可，以1的删除为例，也就是把其双亲3的右子树指针改指向像它的孩子0即可。

3.删除的结点度为2，也就有两棵子树的结点。这个的处理就稍微复杂一点了，因为二叉查找树的特性，根大于左子树小于右子树的。所以删除的需要去寻找前驱/后继结点来补充它的位置。如果删除的根左边的结点（比根小的结点），那么就是找前驱结点，前驱结点是其左子树中最大的结点，前驱结点的右子树一定为空，因为没有比它大的了；如果删除的根右边的结点（比根大的结点），那么就是找后继结点，后继结点是其右子树中最小的结点，后继结点的左子树一定为空，因为没有比它小的了。其实前驱后继就是中序遍历的时候在根前后的两个结点。如此一来，可以看出找到的前驱/后继结点的条件肯定是满足1或者2的，找到这个节点之后，将其覆盖当前要删除的这个节点。各项指针都移动好了，只需要将这个前驱/后继结点删除就可以了，这个节点的删除就和前面两种情况一样的了。

具体每一个注意点可以看下代码注释说明，应该算比较详细，里面涉及的那些结点指针的指向变更，还是比较绕的。

 

package com.nijunyang.algorithm.tree;

import com.nijunyang.algorithm.util.RefObject;

/**
 * Description:
 * Created by nijunyang on 2020/4/19 20:03
 */
public class BinarySearchTree<T extends Comparable<T>> extends TreeNode<T> {
    private T data;
    private BinarySearchTree<T> leftChild;
    private BinarySearchTree<T> rightChild;

    public BinarySearchTree(T data) {
        this.data = data;
    }

    public static void main(String[] args) {
        BinarySearchTree<Integer> binarySearchTree = new BinarySearchTree(5);
        BinarySearchTree.insert(binarySearchTree, 3);
        BinarySearchTree.insert(binarySearchTree, 1);
        BinarySearchTree.insert(binarySearchTree, 4);
        BinarySearchTree.insert(binarySearchTree, 8);
        BinarySearchTree.insert(binarySearchTree, 7);
        BinarySearchTree.insert(binarySearchTree, 9);
        BinarySearchTree.insert(binarySearchTree, 10);
        BinarySearchTree.insert(binarySearchTree, 0);
        TreeUtil.inOrderTraversal(binarySearchTree);
        System.out.println();
        TreeUtil.levelOrder(binarySearchTree);
        System.out.println();
        BinarySearchTree<Integer> integerBinarySearchTree = BinarySearchTree.find(binarySearchTree, 9, new RefObject<>());
        delete(binarySearchTree, 8);
        delete(binarySearchTree, 7);
        TreeUtil.inOrderTraversal(binarySearchTree);
    }

    /**
     * 插入数据
     * @param root
     * @param data
     * @param <T>
     */
    public static <T extends Comparable<T>> void insert(BinarySearchTree<T> root, T data) {
        if (root.data.compareTo(data) < 0) {
            if (root.rightChild == null) {
                root.rightChild = new BinarySearchTree(data);
            } else {
                insert(root.rightChild, data);
            }
        } else {
            if (root.leftChild == null) {
                root.leftChild = new BinarySearchTree(data);
            } else {
                insert(root.leftChild, data);
            }
        }
    }


    /**
     * 查询数据
     * @param root
     * @param data
     * @param parent   用于带出父节点
     * @param <T>
     * @return
     */
    public static <T extends Comparable<T>> BinarySearchTree<T> find(
            BinarySearchTree<T> root, T data, RefObject<BinarySearchTree<T>> parent) {
        if (root.data.compareTo(data) == 0) {
            return root;
        }
        parent.setValue(root);
        if (root.data.compareTo(data) < 0) {
            if (root.rightChild != null) {
                return find(root.rightChild, data, parent);
            }
        } else {
            if (root.leftChild != null) {
                return find(root.leftChild, data, parent);
            }
        }
        return null;
    }

    /**
     * 查询最大数据
     * @param root
     * @param parentRef  返回结果的父结点包装
     * @param <T>
     * @return
     */
    public static <T extends Comparable<T>> BinarySearchTree<T> findMax(
            BinarySearchTree<T> root, RefObject<BinarySearchTree<T>> parentRef) {
        if (root.rightChild != null) {
            parentRef.setValue(root);
            return findMax(root.rightChild, parentRef);
        }
        return root;
    }

    /**
     * 查询最小数据
     * @param root
     * @param parentRef 返回结果的父结点包装
     * @param <T>
     * @return
     */
    public static <T extends Comparable<T>> BinarySearchTree<T> findMin(
            BinarySearchTree<T> root, RefObject<BinarySearchTree<T>> parentRef) {
        if (root.leftChild != null) {
            parentRef.setValue(root);
            return findMin(root.leftChild, parentRef);
        }
        return root;
    }

    /**
     * 删除数据
     * @param root
     * @param data
     * @param <T>
     * @return
     */
    public static <T extends Comparable<T>> void delete(BinarySearchTree<T> root, T data) {

        RefObject<BinarySearchTree<T>> parentRef = new RefObject<>();
        BinarySearchTree<T> delBinarySearchTree = find(root, data, parentRef);
        if (delBinarySearchTree == null) {
            return;
        }
        /**
         * 二叉搜索树结点的删除分三种情况：
         * 1.叶子结点，可以直接删除
         * 2.度为1的结点，可以直接删除（只有一个子树的结点）
         * 3.两棵子树的结点删除，找前驱结点/后继结点。就是删除了该结点，前驱/后继结点可以直接补位
         * 如果删除的根左边的结点，那么就是找前驱结点，前驱结点是其左子树中最大的结点，前驱结点的右子树一定为空，因为没有比它大的了
         * 如果删除的根右边的结点，那么就是找后继结点，后继结点是其右子树中最小的结点，后继结点的左子树一定为空，因为没有比它小的了
         * 如此一来，可以看出找到的前驱/后继结点的条件肯定是满足1或者2的
         */
        BinarySearchTree<T> parent = parentRef.getValue();
        //叶子结点直接将父结点的孩子置空
        if (delBinarySearchTree.leftChild == null && delBinarySearchTree.rightChild == null) {
            if (parent.rightChild == delBinarySearchTree) {
                parent.rightChild = null;
            } else {
                parent.leftChild = null;
            }
        }
        //度为2的结点删除
        else if (delBinarySearchTree.leftChild != null && delBinarySearchTree.rightChild != null) {
            //删除比根大的，删除的结点在根的右边，需要找后继结点
            if (root.data.compareTo(data) < 0) {
                RefObject<BinarySearchTree<T>> postParentRef = new RefObject<>(); //后继结点的父结点
                BinarySearchTree<T> postNode = findMin(root.rightChild, postParentRef);
                //判断要删除的结点是它父结点的左结点还是右结点，修改对应指针指向后继结点
                if (parent.data.compareTo(delBinarySearchTree.data) < 0) {
                    parent.rightChild = postNode;
                } else {
                    parent.leftChild = postNode;
                }
                postParentRef.getValue().leftChild = null; //后继结点因为要移走，所以置空其父结点的左孩子（后继必定是其父的左孩子）
                if (postNode.rightChild != null) {//后继结点的左子树一定为空, 将其父结点的左孩子指向后继结点的右孩子
                    postParentRef.getValue().leftChild = postNode.rightChild;
                    postNode.rightChild = null; //置空相关引用，便于垃圾回收
                }
                //将删除的这个结点的左右子树的指针给到后继结点
                postNode.rightChild = delBinarySearchTree.rightChild;
                delBinarySearchTree.rightChild = null; //置空相关引用，便于垃圾回收
                postNode.leftChild = delBinarySearchTree.leftChild;
                delBinarySearchTree.leftChild = null; //置空相关引用，便于垃圾回收
            }
            //删除根或者比根小的，删除的结点在根的左边，需要找前驱结点
            else{
                RefObject<BinarySearchTree<T>> preParentRef = new RefObject<>(); //前驱结点的父结点
                BinarySearchTree<T> preNode = findMax(root.leftChild, preParentRef);

                if (parent != null) { //如果删除的是根结点 没有父结点
                    //判断要删除的结点是它父结点的左结点还是右结点，修改对应指针指向前驱结点
                    if (parent.data.compareTo(delBinarySearchTree.data) < 0) {
                        parent.rightChild = preNode;
                    } else {
                        parent.leftChild = preNode;
                    }
                }
                preParentRef.getValue().rightChild = null; //前驱结点因为要移走，所以置空其父结点的右孩子（前驱必定是其父的右孩子）
                if (preNode.leftChild != null) {//前驱结点的右子树一定为空, 将其父结点的右孩子指向前驱结点的左孩子
                    preParentRef.getValue().rightChild = preNode.leftChild;
                    preNode.leftChild = null; //置空相关引用，便于垃圾回收
                }

                if (delBinarySearchTree == root) {
                    //删除的是根 直接将交换值
                    delBinarySearchTree.data = preNode.data;
                }
                else {
                    //将删除的这个结点的左右孩子的指针给到前驱结点
                    preNode.rightChild = delBinarySearchTree.rightChild;
                    delBinarySearchTree.rightChild = null; //置空相关引用，便于垃圾回收
                    preNode.leftChild = delBinarySearchTree.leftChild;
                    delBinarySearchTree.leftChild = null; //置空相关引用，便于垃圾回收
                }
            }
        }
        //度为1的结点删除 将其父结点的孩子指向它的孩子
        else {
            BinarySearchTree<T> leftChild = delBinarySearchTree.leftChild;
            BinarySearchTree<T> child =  leftChild == null ? delBinarySearchTree.rightChild : leftChild;
            delBinarySearchTree.leftChild = null;  //置空相关引用，便于垃圾回收
            delBinarySearchTree.rightChild = null; //置空相关引用，便于垃圾回收
            if (parent.data.compareTo(child.data) < 0) {
                parent.rightChild = child;
            } else {
                parent.leftChild = child;
            }
        }
    }


    @Override
    public T getData() {
        return data;
    }

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

    @Override
    public BinarySearchTree<T> getLeftChild() {
        return leftChild;
    }

    public void setLeftChild(BinarySearchTree<T> leftChild) {
        this.leftChild = leftChild;
    }

    @Override
    public BinarySearchTree<T> getRightChild() {
        return rightChild;
    }

    public void setRightChild(BinarySearchTree<T> rightChild) {
        this.rightChild = rightChild;
    }
}

 

遍历代码：

package com.nijunyang.algorithm.tree;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

/**
 * @author: create by nijunyang
 * @date:2019/7/28
 */
public final class TreeUtil {

    private TreeUtil() {
    }


    /**
     * 构造二叉树
     * @param dataList
     * @param <T>
     * @return
     */
    public static <T> TreeNode<T> createBinaryTree(LinkedList<T> dataList) {
        TreeNode<T> node = null;
        if (dataList == null || dataList.isEmpty()) {
            return null;
        }
        T data = dataList.removeFirst();
        if (data != null) {
            node = new TreeNode(data);
            node.setLeftChild((createBinaryTree(dataList)));
            node.setRightChild((createBinaryTree(dataList)));
        }
        return node;
    }

    /**
     * 前序遍历 根 左子树 右子树
     * @param node
     */
    public static<N extends TreeNode<T>, T> void preOrderTraversal(N node) {
        if(node == null){
            return;
        }
        //遇根先输出，再去找左右
        System.out.print(node.getData());
        preOrderTraversal(node.getLeftChild());
        preOrderTraversal(node.getRightChild());
    }

    /**
     * 二叉树中序遍历 左子树 根 右子树
     * @param node   二叉树节点
     */
    public static<N extends TreeNode<T>, T> void inOrderTraversal(N node){
        if(node == null){
            return;
        }
        //先找左再输出根,再去找右
        inOrderTraversal(node.getLeftChild());
        System.out.print(node.getData());
        inOrderTraversal(node.getRightChild());
    }

    /**
     * 二叉树后序遍历  左子树 右子树 根
     * @param node   二叉树节点
     */
    public static<N extends TreeNode<T>, T> void postOrderTraversal(N node){
        if(node == null){
            return;
        }
        //先找左右，最后输出根
        postOrderTraversal(node.getLeftChild());
        postOrderTraversal(node.getRightChild());
        System.out.print(node.getData());
    }

    /**
     * 利用栈前序遍历二叉树
     * @param root
     */
    public static <N extends TreeNode<T>, T> void preOrderTraversalByStack(N root) {
        Stack<TreeNode<T>> stack = new Stack<>();
        TreeNode<T> node = root;
        while(node != null || !stack.isEmpty()) {
            //节点不为空，遍历节点，并入栈用于回溯
            while(node != null) {
                System.out.print(node.getData());
                stack.push(node);
                node = node.getLeftChild();
            }
            //没有左节点，弹出该栈顶节点（回溯），访问右节点
            if(!stack.isEmpty()) {
                node = stack.pop();
                node = node.getRightChild();
            }
        }
    }

    /**
     * 层次遍历
     * @param root
     * @param <T>
     */
    public static <N extends TreeNode<T>, T> void levelOrder(N root) {
        if (root == null) {
            return;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);  //入队
        while (!queue.isEmpty()) {
            TreeNode<T> node = queue.poll(); //取出
            if (node != null) {
                System.out.print(node.getData());
                queue.offer(node.getLeftChild());   //左孩子入队
                queue.offer(node.getRightChild());  //右孩子入队
            }
        }
    }
}

RefObject:

package com.nijunyang.algorithm.util;

/**
 * Description: 引用包装，用于去一个方法里面除开返回值之外，将其他额外需要的数据带出来
 * Created by nijunyang on 2020/4/20 10:26
 */
public class RefObject<E> {

    public RefObject() {
    }

    public RefObject(E value) {
        this.value = value;
    }


    private E value;

    public E getValue() {
        return value;
    }

    public void setValue(E value) {
        this.value = value;
    }
}