二叉排序树

二叉排序树

二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。
是数据结构中的一类。在一般情况下，查询效率比链表结构要高。

比节点的小的子节点是左节点，比节点大的子节点是右节点。

定义一：
一棵空树，或者是具有下列性质的二叉树：
（1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；
（2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值；
（3）左、右子树也分别为二叉排序树；
（4）没有键值相等的结点。

• 定义二
  编辑
  一棵空树，或者是具有下列性质的二叉树：
  （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；
  （2）若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值；
  （3）左、右子树也分别为二叉排序树；
• 定义三

一棵空树，或者是具有下列性质的二叉树：
（1）若左子树不空，则左子树上所有结点的值均小于或等于它的根结点的值；
（2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值；
（3）左、右子树也分别为二叉排序树；

查找

二叉树
二叉树
步骤：若根结点的关键字值等于查找的关键字，成功。
否则，若小于根结点的关键字值，递归查左子树。
若大于根结点的关键字值，递归查右子树。
若子树为空，查找不成功。

首先执行查找算法，找出被插结点的父亲结点。
判断被插结点是其父亲结点的左、右儿子。将被插结点作为叶子结点插入。
若二叉树为空。则首先单独生成根结点。
注意：新插入的结点总是叶子结点。

中序遍历二叉排序树就是从小到大的排列

节点类：

public class TreeNode {
    int value;
    TreeNode leftNode;
    TreeNode rightNode;

    public void setLeftNode(TreeNode leftNode) {
        this.leftNode = leftNode;
    }

    public void setRightNode(TreeNode rightNode) {
        this.rightNode = rightNode;
    }

    public TreeNode(int value) {
        this.value = value;
    }
}

二叉树类：

public class BinarySortTree {
    TreeNode root;
}

在二元排序树中查找元素的过程为：

1.若b是空树，则搜索失败，否则：

2.若x等于b的根节点的数据域之值，则查找成功；否则：

3.若x小于b的根节点的数据域之值，则搜索左子树；否则：

4.查找右子树。
代码实现：

/*查找节点*/
    public TreeNode search(int value) {
        if( root == null){
            return null;
        }
        return root.search(value);
    }

 /*
    * 查找指定节点
    * */
    public TreeNode search(int value) {
        if(this.value == value){
            return this;
        }else if(value < this.value){
            if (this.leftNode != null) {
               return this.leftNode.search(value);
            }
        }else if(value > this.value){
            if(this.rightNode != null){
                return this.rightNode.search(value);
            }
        }
        return null;
    }

二叉排序树的插入

先从二叉排序树的插入说起，因为二叉排序树作为一种动态集合，其特点是树的结构通常不是一次生成的，而是查找过程中，当树中不存在关键字值等于给定值的结点时再进行插入的。所以二叉排序树的构造其实就是个二叉排序树插入的过程。

二叉排序树插入思想和查询思想很接近：若原二叉排序树为空，则直接插入结点；否则，若关键字k小于根结点关键字，则插入左子树；否则插入右子树。

 /*
    * 向二叉排序树中插入节点
    * */
    public void add(TreeNode node){

        if(root == null){
            root = node;
        }else{
            root.add(node);
        }
    }

 /*
    * 向子树中添加节点
    * */
    public void add(TreeNode node) {
        if(node == null){
            return;
        }
        //判断当前节点与该节点的值大小
        if(node.value < this.value){   //如果要小
            //如果当前节点的左子节点为空，就直接添加为左子节点
            if(this.leftNode == null){
                this.leftNode = node;
            }else{  //否则继续递归
                this.leftNode.add(node);
            }
        }

        if( node.value > this.value){    //如果要大
            if(this.rightNode == null){  //如果当前当前节点的右子节点为空，就直接添加为右子节点
                this.rightNode = node;
            }else{  //否则继续递归
                this.rightNode.add(node);
            }
        }
    }

二叉排序树的删除

二叉排序树的删除分三种情况

1、要删除的节点是叶子节点，删除并不会吧破坏整棵树的结构

2、要删除的节点只有左子树或者右子树，删除该节点后让子节点顶替上来就可以

3、要删除的节点既有左子树也有右子树，删除节点后可能会破坏原本的树结构

代码实现

 /*
    * 删除叶子节点*/
    public void deleteNode(int value) {
        if(root == null){
            return;
        }else{
            //找到这个节点
            TreeNode target = search(value);
            //如果没有这个节点
            if(target == null){
                return;
            }
            //如果有这个节点，找到他的父节点
            TreeNode parentNode = searchParent(value);
            //要删除的节点是叶子节点
            if(target.leftNode == null && target.rightNode == null){
                //要删除的节点是父节点的左子节点
                if(value == parentNode.leftNode.value){
                    parentNode.leftNode = null;
                }
                //要删除的是右子节点
                if(value == parentNode.rightNode.value){
                    parentNode.rightNode = null;
                }
            }else if(target.leftNode != null && target.rightNode != null){ //两个子节点

                //删除右子树中的值最小的节点，获取到该节点的值
                int min = deleteMin(target.rightNode);
                //替换掉目标节点的值
                target.value = min;

            }else {   //一个子节点
                //如果要被删除的节点有左子节点
                if(target.leftNode != null){
                    //如果要删除的节点是其父节点的左子节点
                    if(value == parentNode.leftNode.value){
                        parentNode.leftNode = target.leftNode;
                    }else{
                        parentNode.rightNode = target.leftNode;
                    }
                }
                //如果要被删除的节点有 右子节点
                if(target.rightNode != null){
                    //如果要删除的节点是其父节点的左子节点
                    if(value == parentNode.leftNode.value){
                        parentNode.leftNode = target.rightNode;
                    }else {  //如果是右子节点
                        parentNode.rightNode = target.rightNode;
                    }
                }
            }

        }
    }


	/*
    * 删除最小的节点并取值*/
    private int deleteMin(TreeNode rightNode) {
        TreeNode target = rightNode;
        //不断向左找
        while (target.leftNode != null){
            target = target.leftNode;
        }
        deleteNode(target.value);
        return target.value;
    }

    /*找父子节点*/
    public TreeNode searchParent(int value){
        if(root == null){
            return null;
        }else{
            return root.searchParent(value);
        }
    }

 /*搜索父节点*/
    public TreeNode searchParent(int value) {
        //如果当前左子节点和右子节点不为空
        if(this.leftNode != null && this.leftNode.value == value
        || this.rightNode != null && this.rightNode.value == value){
            return this;
        }else {
            if(this.value > value && this.rightNode != null ){
                return this.leftNode.searchParent(value);
            }else if(this.value < value && this.leftNode != null){
                return this.rightNode.searchParent(value);
            }
        }
        return null;
    }

每个结点的Ci为该结点的层次数。最好的情况是二叉排序树的形态和折半查找的判定树相同，其平均查找长度和logn成正比（O(log2(n))）。最坏情况下，当先后插入的关键字有序时，构成的二叉排序树为一棵斜树，树的深度为n，其平均查找长度为(n + 1) / 2。也就是时间复杂度为O(n)，等同于顺序查找。因此，如果希望对一个集合按二叉排序树查找，最好是把它构建成一棵平衡的二叉排序树（平衡二叉树）。