搜索二叉树（Java）

概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:

若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
若它的右子树不为空，则右子树上所有节点的值都大于根节点的值	
它的左右子树也分别为二叉搜索树 

基本操作

1、查找

树不为空的情况下：
（1）key小于根节点的值，去左子树找；
（2）key大于根节点的值，去右子树找；
（3）相等，就找到了，返回该节点
若都没找到，即key不存在，返回null

2、插入

分为两种情况：
（1）若为空树，即root == null
（2）若不是空树，按照查找逻辑，确定插入位置，插入新结点

3、删除（难点）

设待删除结点为 cur, 待删除结点的双亲结点为 parent

（1）树的左子树为空（cur.left == null）

a.	cur 是 root，则 root = cur.right
b.	cur 不是 root，cur 是 parent.left，则 parent.left = cur.right
c.	cur 不是 root，cur 是 parent.right，则 parent.right = cur.right

（2）树的右子树为空 （cur.right == null）

a.	cur 是 root，则 root = cur.left
b.	cur 不是 root，cur 是 parent.left，则 parent.left = cur.left
c.	cur 不是 root，cur 是 parent.right，则 parent.right = cur.left

（3）树的左右子树都不为空（cur.left != null && cur.right != null）

找到待删除节点右子树的最小值，将其与带删除元素交换，最后删除该节点即可 

代码实现

 /搜索二叉树的相关操作
/*
    1、查找
    2、插入
    3、删除
 */

public class BinarySearchTree {

    //二叉树的结构
    public static class Node{
        int key;
        Node left;
        Node right;

        public Node(int key){
            this.key = key;
        }
    }

    private Node root = null;

    //查找

    /*
    思路:
           树不为空的情况下：
                1、key小于根节点的值，去左子树找；
                2、key大于根节点的值，去右子树找；
                3、相等，就找到了，返回该节点
           若都没找到，即key不存在，返回null
     */

    public Node find(int key){
        Node cur = root;
        while(root != null){
            if(key < root.key){
                root = root.left;
            }else if(key > root.key){
                root = root.right;
            }else {
                return root;
            }
        }
        return null;
    }

    //插入

    /*
    思路：
            1、若为空树，直接插入
            2、若不是空树：
               （ 1）按照查找顺序找到要插入的位置；
               （2）插入
     */

    public boolean insert(int key){
        if(root == null){
            root = new Node(key);
            return true;
        }
        Node cur = root;
        Node parent = null;   //cur的双亲节点
        while(cur != null){
            if(key < cur.key){
                parent = cur;
                cur = cur.left;
            }else if(key > cur.key){
                parent = cur;
                cur = cur.right;
            }else{
                //若要插入的元素，原来原来树中有，插入失败；
                return false;
            }
        }   // 该循环结束，说明已经找到要插入的位置，接下来根据key的大小，进行插入
        if(key < parent.key){
            parent.left = new Node(key);
        }else {
            parent.right = new Node(key);
        }
        return true;
    }

    //删除

    /*
    思路：
            1、先查找要删除的元素key，是否在树中；
            2、一共可分为三种情况：
                （1）树的左子树为空
                            a.若要删除结点是根节点(root = cur.right)
                            b.若要删除结点是父节点的左子树(parent.left = cur.right)
                            c.若要删除结点是父节点的右子树(parent.right = cur.right)
                （2）树的右子树为空
                            a.若要删除结点是根节点(root = cur.left)
                            b.若要删除结点是父节点的左子树(parent.left = cur.left)
                            c.若要删除结点是父节点的右子树(parent.right = cur.left)
                （3）树的左右子树都不为空
                            找到待删除节点右子树的最小值，将其与带删除元素交换，最后删除该节点即可
     */

    public boolean remove(int key){
        Node cur = root;
        Node parent = null;
        while(cur != null){
            if(key < cur.key){
                parent = cur;
                cur = cur.left;
            }else if(key > cur.key){
                parent = cur;
                cur = cur.right;
            }else{
                //此时已经找到要删除的元素，在该方法中进行删除
                removeNode(parent,cur);
                return true;
            }
        }
        //此时未找到要删除元素，删除失败
        return false;
    }
    private void removeNode(Node parent, Node cur) {
        //1、若要删除结点的左子树为空
        if(cur.left == null){
            //（1）若要删除结点是根节点
            if(cur == root){
                root = cur.right;
                //（2）若要删除结点是父节点的左子树
            }else if(cur == parent.left){
                parent.left = cur.right;
                //（3）若要删除结点是父节点的右子树
            }else{
                parent.right = cur.right;
            }
            //2、若要删除结点的右子树为空
        }else if(cur.right == null){
            //（1）若要删除结点是根节点
            if(cur == root){
                root = cur.left;
                //(2)若要删除结点是父节点的左子树
            }else if(cur == parent.left){
                parent.left = cur.left;
                //(3)若要删除结点是父节点的右子树
            }else{
                parent.right = cur.left;
            }
            //3、若有删除结点的左右子树都不为空
        }else{
            //(1)先找到走姿树中的最小元素（替罪羊）
            Node goatParent = cur;  // 替罪羊节点的父节点
            Node scapeGoat = cur.right;  // 替罪羊节点
            while(scapeGoat.left != null){
                goatParent =scapeGoat;
                scapeGoat = scapeGoat.left;
            }// 循环结束时, scapeGoat 指向了右子树中的最小值
            // (2) 把刚才找到的替罪羊的值赋给待删除节点
            cur.key = scapeGoat.key;
            // (3) 删除替罪羊节点
            // 替罪羊节点一定没有左子树
            if(scapeGoat == goatParent.left){
                goatParent.left = scapeGoat.right;
            }else{
                goatParent.right = scapeGoat.right;
            }
        }
    }
}

性能分析

1、插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
2、对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
3、但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树 ：
（1）最优情况下，二叉搜索树为完全二叉树，其平均比较次数为：O(log(n))
（2）最差情况下，二叉搜索树退化为单支树，其平均比较次数为：O(n)