用Java实现二叉查找树

二叉查找树的实现

1. 原理

　　二叉查找树，又称为二叉排序树、二叉搜索树。对于树中每一个节点X，它的左子树中所有项的值小于X中的项，而它的右子树中所有项的值大于X中的项。二叉查找树的平均深度为O(log N)，搜索元素的时间复杂度也是O(log N)。是两种库集合类TreeSet、TreeMap实现的基础。

2. public API

void makeEmpty( )      --> 置空
boolean isEmpty( )     --> 判空
AnyType findMin( )     --> 寻找最小值
AnyType findMax( )     --> 寻找最大值
boolean contains( x )  --> 是否存在元素x
void insert( x )       --> 插入元素x
void remove( x )       --> 删除元素x
void printTree( )      --> 遍历二叉树

3. 核心思想图解：递归

！寻找最小值

此处用递归实现：

！寻找最大值

此处用非递归实现，也可以用递归实现：

！是否存在元素x

从root开始往下找，找到含有项X的节点，则此操作返回true，没有找到则返回false。

！插入元素x

从root开始往下找到合适的插入位置，然后插入。

！删除元素x

从root开始往下找到元素x，找到则删除，并且处理好后续工作。

4. BinarySearchTree代码实现

类中，大量使用方法来调用递归方法的技巧，很好地体现了面向对象的封装性。

/**
 * @author: wenhx
 * @date: Created in 2019/10/8 19:41 （之前）
 * @description: 二叉查找树的实现
 */
public class BinarySearchTree<AnyType extends Comparable<? super AnyType>> {
​
    /**
     * 树的根节点
     */
    private BinaryNode<AnyType> root;
​
    /**
     * 定义树的节点（内部类）
     */
    private static class BinaryNode<AnyType> {
​
        AnyType element;            // 元素值
        BinaryNode<AnyType> left;   // 左孩子
        BinaryNode<AnyType> right;  // 右孩子
​
        // 节点的构造器：初始化一个树的节点
        BinaryNode(AnyType theElement) {
            this(theElement, null, null);
        }
​
        BinaryNode(AnyType theElement, BinaryNode<AnyType> lt, BinaryNode<AnyType> rt) {
            element = theElement;
            left = lt;
            right = rt;
        }
    }
​
    /**
     * 二叉排序树的构造器：初始化根节点
     */
    public BinarySearchTree() {
        root = null;
    }
​
    /**
     * 置空
     */
    public void makeEmpty() {
        root = null;
    }
​
    /**
     * 判空
     */
    public boolean isEmpty() {
        return root == null;
    }
​
    /**
     * 寻找最小值
     */
    public AnyType findMin() {
        if (isEmpty()) {
            throw new RuntimeException();
        }
        return findMin(root).element;
    }
​
    /**
     * 寻找最大值
     */
    public AnyType findMax() {
        if (isEmpty()) {
            throw new RuntimeException();
        }
        return findMax(root).element;
    }
​
​
    /**
     * 是否存在元素x
     */
    public boolean contains(AnyType x) {
        return contains(x, root);
    }
​
    /**
     * 插入元素x
     */
    public void insert(AnyType x) {
        root = insert(x, root);
    }
​
    /**
     * 删除元素x
     */
    public void remove(AnyType x) {
        root = remove(x, root);
    }
​
    /**
     * 遍历此二叉树
     */
    public void printTree() {
        if (isEmpty()) {
            System.out.println("Empty tree");
        } else {
            printTree(root);
        }
    }
​
    /**
     * 寻找最小值（内部方法）：此处用递归实现
     */
    private BinaryNode<AnyType> findMin(BinaryNode<AnyType> t) {
        if (t == null) {
            return null;
        } else if (t.left == null) {
            return t;
        }
        return findMin(t.left);
    }
​
    /**
     * 寻找最大值（内部方法）：此处用非递归实现
     */
    private BinaryNode<AnyType> findMax(BinaryNode<AnyType> t) {
        if (t != null) {
            while (t.right != null) {
                t = t.right;
            }
        }
        return t;
    }
​
    /**
     * 是否存在元素x（内部方法）
     */
    private boolean contains(AnyType x, BinaryNode<AnyType> t) {
        /**
         * 跳出递归的条件
         */
        if (t == null) {
            return false;
        }
​
        /**
         * 如果x小于节点值，则递归到左孩子；
         * 如果x大于节点值，则递归到右孩子；
         * 如果x等于节点值，则找到。
         */
        int compareResult = x.compareTo(t.element);
​
        if (compareResult < 0) {
            return contains(x, t.left);
        } else if (compareResult > 0) {
            return contains(x, t.right);
        } else {
            return true;
        }
​
    }
​
    /**
     * 插入元素x（内部方法）
     */
    private BinaryNode<AnyType> insert(AnyType x, BinaryNode<AnyType> t) {
        /**
         * 跳出递归的条件
         */
        if (t == null) {
            return new BinaryNode<>(x, null, null);
        }
​
        /**
         * 如果x小于节点值，则递归到左孩子；
         * 如果x大于节点值，则递归到右孩子；
         * 如果x等于节点值，则说明已有元素x，无需操作。
         */
        int compareResult = x.compareTo(t.element);
​
        if (compareResult < 0) {
            t.left = insert(x, t.left);
        } else if (compareResult > 0) {
            t.right = insert(x, t.right);
        } else {
        }
        return t;
​
    }
​
    /**
     * 删除元素x（内部方法）
     */
    private BinaryNode<AnyType> remove(AnyType x, BinaryNode<AnyType> t) {
        /**
         * 跳出递归的条件
         */
        if (t == null) {
            return t;   // Item not found; do nothing
        }
​
        /**
         * 如果x小于节点值，则递归到左孩子；
         * 如果x大于节点值，则递归到右孩子；
         * 如果x等于节点值，则要删除此节点。
         */
        int compareResult = x.compareTo(t.element);
​
        if (compareResult < 0) {
            t.left = remove(x, t.left);
        } else if (compareResult > 0) {
            t.right = remove(x, t.right);
        } else if (t.left != null && t.right != null) {
            // 要删除的节点有两个孩子（可选用右孩子最小元素/左孩子最大元素上调）
            t.element = findMin(t.right).element;
            t.right = remove(t.element, t.right);
        } else {
            // 要删除的节点有一个孩子或者没有孩子
            t = (t.left != null) ? t.left : t.right;
        }
        return t;
    }
​
    /**
     * 遍历此二叉树（内部方法）
     */
    private void printTree(BinaryNode<AnyType> t) {
        // 中序遍历-->即递增顺序
        if (t != null) {
            printTree(t.left);
            System.out.println(t.element);
            printTree(t.right);
        }
    }
​
    /**
     * 求树的深度（内部方法）
     */
    private int height(BinaryNode<AnyType> t) {
        if (t == null) {
            return -1;
        } else {
            return 1 + Math.max(height(t.left), height(t.right));
        }
    }
​
    /**
     * 主方法用来测试
     */
    public static void main(String[] args) {
        BinarySearchTree<Integer> t = new BinarySearchTree<>();
        t.insert(6);
        t.insert(3);
        t.insert(9);
        t.insert(2);
        t.insert(5);
        t.insert(8);
        t.insert(10);
        t.printTree();
        t.insert(4);
    }
}

okay，今天就到这啦，一定要掌握这种数据结构哈，真的很重要！！！