常见的查找算法（五）：树表查找之一 ---- 二叉查找树

二叉查找树（英语：Binary Search Tree），也称为二叉搜索树、有序二叉树（ordered binary tree）或排序二叉树（sorted binary tree），是指一棵空树或者具有下列性质的二叉树：

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

二叉查找树的节点：

    //二叉树节点
    static class BSTNode<T> {
        T data;
        BSTNode<T> parent;
        BSTNode<T> left;
        BSTNode<T> right;

        public BSTNode() {
            this.data = null;
            this.left = left;
            this.right= 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;
        }
    }

查找操作：

    /******************************* 查找 start *******************************/

    /**
     * 从根节点查找
     *
     * @param data 要查找的元素
     * @return
     */
    public boolean searchBST(T data) {
        return searchBST(data, root);
    }

    /**
     * 递归查找指定元素是否在树中
     *
     * @param node 树中节点
     * @param data 要查找的元素
     * @return
     */
    public boolean searchBST(T data, BSTNode<T> node) {
        if (node == null)
            return false;

        count++;
        int result = data.compareTo(node.data);

        if (result > 0) {
            return searchBST(data, node.right);//往右子树查询
        } else if (result < 0) {
            return searchBST(data, node.left);//往左子树查询
        } else {
            return true;
        }
    }

    /**
     * 寻找二叉树中最大的元素
     *
     * @return
     */
    public T findMax() {
        if (isEmpty()) {
            System.out.println("二叉树为空");
            return null;
        } else {
            return findMax(root).data;
        }
    }

    /**
     * 寻找二叉树中最大的元素
     *
     * @param node 当前的结点
     * @return
     */
    public BSTNode<T> findMax(BSTNode<T> node) {
        if (node == null) {
            return null;
        } else if (node.right == null) {
            return node;
        } else {
            //迭代
            while (node.right != null) {
                node = node.right;
            }
            return node;
        }
    }

    /**
     * 寻找二叉树中最小的元素
     *
     * @return
     */
    public T findMin() {
        if (isEmpty()) {
            System.out.println("二叉树为空");
            return null;
        } else {
            return findMin(root).data;
        }
    }

    /**
     * 寻找二叉树中最小的元素
     *
     * @param node 当前节点
     * @return
     */
    public BSTNode<T> findMin(BSTNode<T> node) {
        if (node == null)
            return null;
        else if (node.left == null)
            return node;
        return findMin(node.left);
    }

    /******************************* 查找 end *******************************/

时间复杂度分析：根据二叉查找树的性质，给定一个元素，去查找树中的元素，是从根节点那开始一层层比较节点的值，从而选定在树中查找的方向。当查找到该元素时，已经比较了n层，也就是元素在树中的层数（根节点为第一层），每层比较一个节点，然而二叉树的高度与它的节点数量有关，为log₂（n+1），所以二叉查找树的朝招时间复杂度为O(log₂n)。

插入操作：

1. 若此树是空树，则直接将插入的结点作为根结点插入。
2. 插入的值等于插入的值的根结点的数据的值，则直接返回，否则。
3. 若插入的值小于此树的根结点的数据的值，则将要插入的结点的位置改变为此树的左子树，否则4。
4. 将插入的值的结点的位置改变为此树的右子树。

    /******************************* 插入 start *******************************/
    //插入元素
    public void insert(T t) {
        root = insert(t, root);
    }

    /**
     * 构建一个二叉查找树
     *
     * @param t    插入元素
     * @param node 插入结点
     * @return
     */
    public BSTNode<T> insert(T t, BSTNode<T> node) {
        if (node == null)
            return new BSTNode<T>(t, null, null);
        int result = t.compareTo(node.data);
        if (result < 0) {
            node.left = insert(t, node);
        } else if (result > 0) {
            node.right = insert(t, node);
        } else {
            System.out.println("插入失败");
        }
        return node;
    }
    /******************************* 插入 end *******************************/

删除操作：

对于二叉查找树的删除操作（这里根据值删除，而非结点）分三种情况：

1. 如果结点为叶子结点（没有左、右子树），此时删除该结点不会破坏树的结构，直接删除即可，并修改其父结点指向它的引用为null
2. 如果其结点只包含左子树，或者右子树的话，此时直接删除该结点，并将其左子树或者右子树设置为其父结点的左子树或者右子树即可，此操作不会破坏树结构
3. 当结点的左、右子树都不空的时候，一般的删除策略是用其右子树的最小数据（容易找到）代替 要删除的结点数据并递归删除该结点（此时为null）

    /******************************* 删除 start *******************************/
    /**
     * 删除元素
     * @param t
     */
    public void remove(T t) {
        root = remove(t, root);
    }

    /**
     * 删除某个位置的结点
     * @param t
     * @param node
     * @return
     */
    public BSTNode<T> remove(T t, BSTNode<T> node) {
        if (node == null) {
            System.out.println("删除失败");
            return node;
        }
        int result = t.compareTo(node.data);
        if (result > 0) {
            node.right = remove(t, node.right);
        } else if (result < 0) {
            node.left = remove(t, node.left);
        } else if (node.left != null && node.right != null) {
            node.data = findMin(node.right).data;
            node.right = remove(node.data, node.right);
        } else {
            node = (node.left != null) ? node.left : node.right;
        }
        return node;
    }
    /******************************* 删除 end *******************************/

遍历二叉查找树（先序遍历）：

    public void preOrder(BSTNode node) {
        if (node != null) {
            System.out.print(node.data + " ");
            preOrder(node.left);
            preOrder(node.right);
        }
    }

测试代码：

    public static void main(String[] args) {
        BSTNode<Integer> node3 = new BSTNode<>(3);
        BSTNode<Integer> node1 = new BSTNode<>(1);
        BSTNode<Integer> node4 = new BSTNode<>(4, node3, null);
        BSTNode<Integer> node2 = new BSTNode<>(2, node1, node4);
        BSTNode<Integer> node8 = new BSTNode<>(8);
        BSTNode<Integer> root = new BSTNode<>(6, node2, node8);

        BSTree bsTree = new BSTree<>();
        bsTree.root = root;
        bsTree.preOrder(bsTree.root);
        //bsTree.remove(4);
        //System.out.println();
        //bsTree.preOrder(bsTree.root);
        bsTree.searchBST(3);
        System.out.println("查找次数：" + count);
    }