二叉搜索树

前面有学习过二叉树，二叉搜索树（也叫做二叉查找树或者二叉排序树）也是一种二叉树，主要其搜索速度非常快，接下来了解一下。

二叉搜索树特点

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

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

（3）子树同样满足上述两点

如下就是一颗典型的二叉搜索树，可以看出从根结点'5'开始，左子结点为'3'，右子结点为'8'，满足上述规则，然后以'3'为根结点，依然符合上述规则，其他也均符合。二叉搜索树的查找速度是非常快的，其时间复杂度就是二叉树的深度，通过下图很好理解，查找一个数最多就是查询到叶子结点，其次数就是二叉树的深度，因此时间复杂度为O(logn)。

有趣的是，将上面这棵二叉搜索树进行中序遍历，发现结果为1,3,4,5,8,9，其恰好是一个排序好的顺序，因此二叉搜索树也叫做二叉排序树。

二叉树插入数据

在了解了二叉树的特点后，如果给一串数字，如何用代码将其存入二叉树呢。其实在了解了上面的特点后，使用递归的方法就能写出实现代码。

/**
 * 二叉搜索树
 */
public class BinarySearchTree {
    //定义属性
    private int data;//数据
    private BinarySearchTree left;//左子树
    private BinarySearchTree right;//右子树

    //构造方法
    public BinarySearchTree(int data, BinarySearchTree left, BinarySearchTree right) {
        this.data = data;
        this.left = left;
        this.right = right;
    }

    //插入一个数字到结点
    public static void insert(BinarySearchTree root,int number) {
        //插入到左子树
        if (number < root.data) {
            //如果左子树没有
            if (root.left == null) {
                root.left = new BinarySearchTree(number, null, null);
            }
            //如果左子树有结点，将左子树起始结点作为根结点接续执行插入逻辑
            if(root.left!=null){
                insert(root.left,number);
            }
        }
        //插入到右子树
        if(number>root.data){
            //如有右子树没有
            if(root.right==null){
                root.right=new BinarySearchTree(number,null,null);
            }
            //如果右子树有结点，将右子树起始结点作为根结点接续执行插入逻辑
            if(root.right!=null){
                insert(root.right,number);
            }
        }

    }
    //使用中序遍历输出排序结果，使用了递归
    public static void in(BinarySearchTree node){
        //左子树→根结点→右子树
        if(node.left!=null){
            in(node.left);
        }
        System.out.print(node.data+",");
        if(node.right!=null){
            in(node.right);
        }
    }
    //测试
    public static void main(String[] args) {
        int[] data=new int[]{55,200,25,32,17,67,300};
        //将数组第一个元素作为根结点
        BinarySearchTree tree=new BinarySearchTree(data[0],null,null);
        //开始插入数组到二叉搜索树
        for (int i = 1; i < data.length; i++) {
            tree.insert(tree,data[i]);
        }
        //使用中序遍历输出
        in(tree);
    }
}

控制台输出情况，可以看出数字能正常插入二叉树，并使用中序遍历可输出排序后的数组。

二叉搜索树查找数据

以上面这个数组为例，如果要查找9，需要查找多少次呢？首先是从根结点进入，然后依次进行如下判断：

（1）9比5大，因此进入右边子树找到8

（2）9比8大，因此进入右边子树找到9，这样就找到了，结束查找

发现只需要找2次就可以找到需要数字，如果遍历的话最多需要5次，当一个数组非常大的时候，二叉搜索树的查找优势就明显体现出来，如下例。

问题：如果上述数组的大小是一个20亿长度大小的数组，要找到一个数最多需要多少次呢？

分析：假设这20亿个数组成了一个满平衡二叉树，先计算一下这棵数的深度，就可以判断出最多需要找多少次了。

解决过程：参考上篇博客，如果是n个结点的满二叉树计算深度，可以假设深度为x，这样2^x-1=n，然后得到2^x=n+1，最后得到深度x=log2^(n+1)，所以深度等于log2^(20亿)，由于2^32约等于21亿，因此深度约等于32，在理想情况下只需要32次就可以找到了。在极端的情况下，如下图所示当二叉树退化成一个链表时，这样最多需要寻找20亿次，这种情况需要使用平衡二叉树来存储数据会更好，平衡二叉树在插入数据的时候还有左旋和右旋动作，会让树形结构左右更加平衡。

如果是二叉搜索树来查找数据，用代码如何来实现呢，其实也是需要用到递归，先写一段逻辑完成对一个结点的比较查询，然后将新找到的子树顶端结点作为根结点继续查找，在上面代码中添加如下方法。

//从根结点进入二叉树，开始查找一个数
    public static void find(BinarySearchTree root,int number){
        //先和根结点数字进行比较
        if(root.data==number){
            System.out.println("二叉树中查找到了数字"+number);
        }
        //进入左子树查找
        if(number<root.data){
            if(root.left==null){
                System.out.println("左子树没有这个数");
            }else{
                find(root.left,number);
            }
        }
        //进入右子树查找
        if(number>root.data){
            if(root.right==null){
                System.out.println("右子树没有这个数");
            }else{
                find(root.right,number);
            }
        }
    }

测试代码，在二叉树中查找55，17，200三个数。

    public static void main(String[] args) {
        int[] data=new int[]{55,200,25,32,17,67,300};
        //将数组第一个元素作为根结点
        BinarySearchTree tree=new BinarySearchTree(data[0],null,null);
        //开始插入数组到二叉搜索树
        for (int i = 1; i < data.length; i++) {
            tree.insert(tree,data[i]);
        }
        //使用中序遍历输出
        in(tree);
        //查找某个数
        System.out.println();
        find(tree,55);
        find(tree,17);
        find(tree,301);
    }

控制台输出情况，发现可以正常得到结果。

上面自己写的查找方法使用了递归，也可以不使用递归，使用while循环来完成查找，如果查找数不等于当前结点的数值，就移动比较的结点到左子树或右子树结点，然后继续比较，如此往复。

//不使用递归来查找
    public static void findByWhile(BinarySearchTree root,int number){
        boolean isExist=false;
        while(root!=null){
            if(number==root.data) {
                System.out.println("查找到的数为" + number);
                isExist=true;
                break;
            }else{
                if(number<root.data){
                    root=root.left;
                }
                if(number>root.data){
                    root=root.right;
                }
            }
        }
        //最后判断是否有这个数
        if(!isExist){
            System.out.println("子树中没有这个数");
        }
    }

控制台输出结果可以看出也可以实现查找，测试代码这里省略。

结论

二叉搜索树是一种查询速度非常快的排序树，其根据根结点的选择，可能是平衡树也可能是非平衡树，在非平衡的情况下查找可能退化成链表，理想情况下查询次数非常少。