玩转数据结构(08)--二分搜索树_数据结构二分法查找树-优快云博客

二分搜索树(Binary Search Tree)

一、树结构

使用树结构的原因：

1.树结构是一种天然的组织结构

2.数据使用树结构存储后，查找高效

二叉树：是动态数据结构【不需要在创建数据结构的时候就决定好要存储多少数据，要添加元素就 new 一个新的空间加入到其中即可，删除二、基础概念同理】

节点 Node 中，除了要存放元素 e 之外，还要存储两个指向其他节点的引用 left【左孩子】和 right 【右孩子】

二叉树要点：

1.二叉树具有唯一的根节点；

2.二叉树中每个节点最多有两个孩子，每个节点最多有一个父亲节点；一个孩子也没有的叫做叶子节点

3.二叉树具有天然的递归结构【每个节点的左子树也是二叉树、每个节点的右子树也是二叉树】

4.二叉树不一定都是“满”的【满二叉树：除叶子节点外，每个节点都有两个孩子】

5.一个节点、甚至 NULL 也是二叉树

二分搜索树：

1.二分搜索树是二叉树

2.二分搜索树的每个节点的值：大于其左子树的所有节点的值且小于其右子树的所有节点的值

3.二分搜索树的每个子树也是二分搜索树

4.存储的元素必须具有可比较性【存储自定义数据类型，必须自定义好数据的比较方式】

示例代码：BST.java【实现基本二分搜索树结构】

public class BST<E extends Comparable<E>> {		//E 要满足Comparable接口，要有可比较性

    private class Node {	//声明对应的节点类型
        public E e;
        public Node left, right;

        public Node(E e) {
            this.e = e;	//e为用户传来的e
            left = null;	//左孩子初始化
            right = null;	//右孩子初始化
        }
    }

    private Node root;	//根节点root
    private int size;	//size 记录当前二叉树存储元素的数量

    public BST(){	//二分搜索树的构造函数
        root = null;
        size = 0;
    }

    public int size(){
        return size;
    }

    public boolean isEmpty(){	//二分搜索树为空
        return size == 0;
    }
}

三、向二分搜索树中添加元素

图解步骤

特殊情况（有重复的话，该元素就相当于已经存在于树中，不做任何改变）

如果想要包含重复元素，只需定义：左子树 <= 节点；右子树 >= 节点【只需将 = 关系放到定义中即可】

代码实现：BST.java

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

    private class Node {
        public E e;
        public Node left, right;

        public Node(E e) {
            this.e = e;
            left = null;
            right = null;
        }
    }

    private Node root;
    private int size;

    public BST(){
        root = null;
        size = 0;
    }

    public int size(){
        return size;
    }

    public boolean isEmpty(){
        return size == 0;
    }

    // 向二分搜索树中添加新的元素e
    public void add(E e){

        if(root == null){
            root = new Node(e);		//根节点直接指向新建的元素即可
            size ++;
        }
        else
            add(root, e);	//从根节点添加新元素e
    }

    // 向以node为根的二分搜索树中插入元素e，递归算法
    private void add(Node node, E e){	//传入参数 Node 与 e
        if(e.equals(node.e))	//【递归的终止条件】传入的e已经存在于树中
            return;
        else if(e.compareTo(node.e) < 0 && node.left == null){	//插入的e比Node节点中的e小，插入左子树中
            node.left = new Node(e);	//左子树为空，直接让node的左孩子为新插入的e
            size ++;
            return;
        }
        else if(e.compareTo(node.e) > 0 && node.right == null){//插入的e比Node节点中的e大，插入右子树中
            node.right = new Node(e);//右子树为空，直接让node的右孩子为新插入的e
            size ++;
            return;
        }

        if(e.compareTo(node.e) < 0)	//递归调用，插入的e比Node节点中的e小，e插入左子树
            add(node.left, e);
        else //e.compareTo(node.e) > 0
            add(node.right, e);	//node 的右孩子成为元素e
    }
}

精简代码：BST.java( NULL 也是一个子树)

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

    private class Node {
        public E e;
        public Node left, right;

        public Node(E e) {
            this.e = e;
            left = null;
            right = null;
        }
    }

    private Node root;
    private int size;

    public BST(){
        root = null;
        size = 0;
    }

    public int size(){
        return size;
    }

    public boolean isEmpty(){
        return size == 0;
    }

    // 向二分搜索树中添加新的元素e
    public void add(E e){
        root = add(root, e);
    }

    // 向以node为根的二分搜索树中插入元素e，递归算法
    // 返回插入新节点后二分搜索树的根 
    private Node add(Node node, E e){
        if(node == null){	//只要node 为null,则必须新插入节点
            size ++;
            return new Node(e); //将节点与二叉树挂接起来
        }

        if(e.compareTo(node.e) < 0)
            node.left = add(node.left, e);	//插入元素e
        else if(e.compareTo(node.e) > 0)
            node.right = add(node.right, e);

        return node;
    }
}

四、二分搜索树的查询操作

示例代码：BST.java

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

    private class Node {
        public E e;
        public Node left, right;

        public Node(E e) {
            this.e = e;
            left = null;
            right = null;
        }
    }

    private Node root;
    private int size;

    public BST(){
        root = null;
        size = 0;
    }

    public int size(){
        return size;
    }

    public boolean isEmpty(){
        return size == 0;
    }

    // 向二分搜索树中添加新的元素e
    public void add(E e){
        root = add(root, e);
    }

    // 向以node为根的二分搜索树中插入元素e，递归算法
    // 返回插入新节点后二分搜索树的根
    private Node add(Node node, E e){
        if(node == null){
            size ++;
            return new Node(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;
    }

    // 看二分搜索树中是否包含元素e（新增代码）
    public boolean contains(E e){
        return contains(root, e);
    }

    // 看以node为根的二分搜索树中是否包含元素e, 递归算法（新增代码）
    private boolean contains(Node node, E e){

        if(node == null)  	// 节点为空，必然不存在
            return false;

        if(e.compareTo(node.e) == 0)	//插入元素e 与节点中的e相同
            return true;
        else if(e.compareTo(node.e) < 0)
            return contains(node.left, e);	//去node左子树中查找
        else // e.compareTo(node.e) > 0
            return contains(node.right, e);//去node右子树中查找
    }
}