二叉搜索树以及对二叉搜索树平衡调整

代码的思想和图片参考：好大学慕课浙江大学陈越、何钦铭的《数据结构》

我们首先介绍一下什么是二叉搜索树和二叉平衡树：

二叉搜索树：一棵二叉树，可以为空；如果不为空，满足以下性质
1. 非空左子树的所有键值小于其根结点的键值。
2. 非空右子树的所有键值大于其根结点的键值。
3. 左、右子树都是二叉搜索树。

二叉搜索树操作的特别函数：
Position Find( ElementType X, BinTree BST )：从二叉搜索树BST
中查找元素X，返回其所在结点的地址,查找的次数取决于树的高度
    算法思想：
    和二分查找类似，如果大于根元素往右边找，小于根元素网左边找，可以使用递归和非递归的方法实现
        注:对尾递归，可以用循环来实现。

Position FindMin( BinTree BST )：从二叉搜索树BST中查找并返回
最小元素所在结点的地址
    算法思想:最小的元素在二叉搜索树的最左分支的端节点上。一直向左进行递归查找即可

Position FindMax( BinTree BST ) ：从二叉搜索树BST中查找并返回
最大元素所在结点的地址
    算法思想：最小的元素在二叉搜索树的最右分支的端节点上。一直向右进行递归查找即可

BinTree Insert( ElementType X, BinTree BST )
    算法思想：和Find的方法差不多，先找到需要插入的位置，然后进行插入
BinTree Delete( ElementType X, BinTree BST )
    算法思想：分为三种情况
        1.删除的节点是叶子节点：直接删除
        2.删除的节点只有一个孩子:删除该节点，把该节点的唯一的子节点挂到父节点上
        3.该节点是有两个孩子的父节点：我们可以把两个孩子的节点看做是有一个孩子的父节点，但是必须从其子节点找到元素来
        替换他，下面是找元素替换的方法。
            3.1查找该节点左子树的最大元素，把最大元素的值给该节点，然后把那个左子树最大元素的节点删除
            3.2查找该节点右子树的最小元素，把最小元素的值给该节点，然后把那个右子树最小元素的节点删除

            为什么需要找最大或者最小元素呢，因为这样可以最大或者最小元素可以保证该节点只有一个子节点或者没有节点
            否则找到一个具有两个节点的父节点，问题还是没有解决。
        



    
平衡二叉树:对于二叉搜索树来说，搜索的次数取决于树的高度，那么，由于元素的插入顺序和规则的不同
    那么所生成树的形状和高度也不相同。可以参考讲义的十二个月份按照不同规则插入，造成二叉搜索树的高度差异有很大
    我们希望树比较平衡，这样平均查找次数就比较少
    
    定义:
    平衡因子(Balance Factor,简称BF):BF(T)=hl-hr,
    hl和hr为左右子树的高度
    
    平衡二叉树的定义(Balance Binary tree 或者称为AVL树):
        1.空树
        2.任意节点左右子树的高度差不超过1，即|BF|<=1

    那么我们需要思考，n个节点的平衡二叉树的高度为多少呢？能不能满足我们的需求呢。
    我可以找规律，我们指定只有一个节点时，高度为0，那么就有如下规律
        平衡二叉树的高度    平衡二叉树需要的最少节点个数
            0            1        A
            1            2
            2            4
            ...            ...
            
    具体的规律和证明参考讲义，最终我们得到一个结论：给定节点为N的AVL树的最大高度为O(Log2 N)


    平衡二叉树的调整问题：
    为什么需要调整平衡儿茶树呢？因为我们队平衡二叉树的插入和删除操作，可能会破坏
    树的平衡性，所以我们需要对树的平衡性进行调整。

平衡二叉树的调整图文解析

注：数字代表平衡因子

平衡二叉树的调整

注：数字代表平衡因子

1 RR调整

调整的演示图

 

上面的不平衡的搜索树的发现者是Mar，麻烦节点是Nov，Nov在发现者的右子树的右边，因而叫做RR插入，需要进行RR旋转(右单旋)

下面给出RR调整的通用的图解：

 

2 LL调整

 LL调整的演示图：

发现者Mar，麻烦节点为Apr在发现者的左子树的左边，因而叫LL插入，需要LL旋转

下面是LL调整的通解图：

 

3 LR调整

LR调整的演示图

 

发现节点是May，麻烦节点是Jan，Jan在May左子树的右子树中，因而叫做LR插入，需要进行LR旋转

LR调整的通解图：

 

4 RL调整

RL调整的演示图：

 

发现节点是Aug，麻烦节点是Feb，Feb在Aug的右子树的左子树上面，因而叫做RL插入，需要进行RL旋转

RL调整的通解图：

 

下面是二叉搜索树的相关操作的代码：

#include<stdio.h>
#include<stdlib.h>

typedef int elementType;

/*define a binary tree*/
typedef struct node{
    elementType element;
    struct node *left;
    struct node *right;
    int treeHeight;/*为了平衡二叉树计算方便，定义树高*/
}tre,*pTree;

/*二叉搜索树的递归查找*/
pTree find(elementType element,pTree tree){
    if(!tree){
        return NULL;
    }
    if(element<tree->element){
        /*查找元素比根元素小在左子树中查找*/
        return  find(element,tree->left);
    }else if(element>tree->element){
        /*查找元素比根元素小在右子树中查找*/
        return find(element,tree->right);
    }else{/*找到该节点，返回*/
        return tree;
    }
}

/*因为递归方法执行的效率低，而且上面的尾递归函数可以改写为递归函数*/
pTree find2(elementType element,pTree tree){
    pTree temp;
    temp = tree;
    while(temp){
        if(element<temp->element){
            temp=temp->left;
        }else if(element>temp->element){
            temp=temp->right;
        }else{
            return temp;
        }
    }
    return NULL;
}

/*根据二叉搜索树的特点，最小元素在最左边的节点上面*/
pTree getMinElement(pTree tree){
    if(tree){
         while(tree->left){
            tree=tree->left;
         }
    }

    return tree;
}

/*获取二叉搜索树中的最大元素，最大元素的位置应该在最右边的节点上*/
pTree getMaxElement(pTree tree){
    if(tree){
        while(tree->right){
            tree = tree->right;
        }
    }

    return tree;
}

/*二叉搜索树的插入，知识遵循二叉搜索树的性质，但是并没有调节平衡*/
pTree insert(pTree tree,elementType element){
    pTree temp;
    if(!tree){
        tree = (pTree)malloc(sizeof(tre));
        tree->element=element;
        tree->left=tree->right=NULL;
    }else{/**/
        if(element<tree->element){
            tree ->left = insert(tree->left,element);
        }
        else if(element>tree->element){
            tree->right = insert(tree->right,element);
        }
    }
    return tree;
}

/*非递归的二叉搜索树的算法*/
pTree insert2(pTree tree,elementType element){
    pTree temp;
    int flag;
    pTree parent;
    if(!tree){
        tree = (pTree)malloc(sizeof(tre));
        tree->element=element;
        tree->left=tree->right=NULL;
    }else{
        temp=tree;
        while(temp!=NULL){
            if(element<temp->element){
                //printf("lala
");
                parent = temp;
                temp=temp->left;
                flag=0;
            }else if(element>temp->element){
                parent = temp;
                flag=1;
                temp=temp->right;
            }
        }

        temp = (pTree)malloc(sizeof(tre));
        temp->element=element;
        temp->left=temp->right=NULL;
        if(flag){
            parent->right=temp;
        }else{
            parent->left=temp;
        }
    }

    return tree;
}

/*在二叉搜索树中删除一个元素
    算法思想：
        1.首先查找到该元素
        2.如果该元素是叶子节点，直接删除
        3.如果该元素有一个孩子节点，直接把孩子节点挂载到该节点的父节点上
        4.如果该节点有两个孩子，由两种方法
            a.在该节点的左子树中找到最大元素节点T，把该节点的值替换成T的值，然后执行对T的删除操作
            b.在该节点的右子树中找最小元素的节点T，把该节点的值替换为T的值，然后执行对T的删除操作
        注：找最大或者最小元素是因为最大最小元素是叶子节点或者只有一个孩子。
*/
pTree deleteElement(pTree tree,elementType element){
    pTree temp;
    if(!tree){
        printf("the element don't search in this tree
");
    }else if(element<tree->element){
        tree->left=deleteElement(tree->left,element);
    }else if(element>tree->element){
        tree->right = deleteElement(tree->right,element);
    }else{//找到需要删除的元素节点
        if(tree->left && tree->right){//该有两个孩子节点
            temp = getMinElement(tree->right);/*获取右子树的最小值节点*/
            tree->element=temp->element;
            tree->right=deleteElement(tree->right,temp->element);
        }else{
            temp=tree;
            if(!tree->left){
                tree=tree->right;
            }else if(!tree->right){
                tree=tree->left;
            }
            free(temp);
        }
    }
    return tree;
}

/*使用非递归的方法
pTree deleteElement2(pTree tree,elementType element){
    pTree temp,maxSubNode,flag,temp2;
    if(!tree){
        printf("the tree is empty,don't allow delete elememt
");
    }else{
       temp = find(element,tree);
       if(temp==NULL){
            printf("the element don't exsit in this tree
");
       }else{
            if(temp->left && temp->right){
                maxSubNode = getMinElement(temp->right);
                temp->element = maxSubNode->element;
            }else{
                maxSubNode = temp;
            }

                temp2=maxSubNode;
                if(!maxSubNode->left){
                    maxSubNode=maxSubNode->right;
                }else if(!maxSubNode->right){
                    maxSubNode=maxSubNode->left;
                }
                free(temp2);
       }

    }
    return tree;
}*/


//先序遍历
void preOrderTraversal(pTree tree){
    if(tree){
        printf("%d ",tree->element);
        preOrderTraversal(tree->left);
        preOrderTraversal(tree->right);
    }
}

/*=====================================调整树为平衡二叉树===============================================*/

int getMaxValue(int a,int b){
    return a > b ? a : b ;
}

/*获取二叉树的树高*/
int getHeight(pTree tree){
    int leftHeight,rightHeight;
    if(tree){
        leftHeight = getHeight(tree->left);
        rightHeight = getHeight(tree->right);
        return (leftHeight>rightHeight ? leftHeight : rightHeight)+1;
    }
    return 0;
}
/*
左单旋操作：将A与B进行LL旋转，并更新A和B的新高度，返回新的根节点B
A必须有一个左子节点B
*/
pTree singleLeftRatation(pTree A){
    pTree B = A->left;
    A->left=B->right;
    B->right = A;
    A->treeHeight = getMaxValue(getHeight(A->left),getHeight(A->right))+1;
    B->treeHeight = getMaxValue(B->left,A->treeHeight)+1;
    return B;
}

/*右单旋:将A与B进行RR旋转，并更新A与B的高度,返回新的根节点B
注：A必须有一个右节点B
*/
pTree singleRightRatation(pTree A){
    pTree B = A->right;
    A->right = B->left;
    B->left = A;
    A->treeHeight = getMaxValue(getHeight(A->left),getHeight(A->right))+1;
    B->treeHeight = getMaxValue(getHeight(B->right),A->treeHeight);
    return B;
}

/*
将A做LR旋转，返回新的根节点C
A必须有一个左自己的B，B必须有一个右子节点C
*/
pTree doubleLeftRightRatation(pTree A){
    /*先对B，C进行RR旋转,C被返回*/
    A->left = singleRightRatation(A->left);
    /*在对A和C进行LL旋转，返回新的根节点C*/
    return singleLeftRatation(A);
}

/*
对A进行RL旋转，返回新的根节点C
注：A必须有一个右子节点B，B必须有一个左子节点C
*/
pTree doubleRightLeftRatation(pTree A){
    /*先对B，C进行LL旋转,返回新的根节点C*/
    A->right = singleLeftRatation(A->right);
    /*在对A，C进行RR旋转，返回新的根节点C*/
    return singleRightRatation(A);
}

/*对二叉搜索树进行插入，插入后调整树的平衡*/
pTree AVLInsert(pTree tree,elementType element){
    if(!tree){
        tree = (pTree)malloc(sizeof(tre));
        tree->element = element;
        tree->left=tree->right = NULL;
        tree->treeHeight=0;
    }else if(element<tree->element){
        tree->left = AVLInsert(tree->left,element);
        //判断平衡因子是否等于2
        if(getHeight(tree->left)-getHeight(tree->right) == 2){
            if(element<tree->left->element){//element往tree的左子树的左子树插入导致平衡因子大于2，进行LL调整的
                tree = singleLeftRatation(tree);
            }else{//element往tree的左子树的右子树插入导致平衡因子大于2，进行LR调整
                tree = doubleLeftRightRatation(tree);
            }
        }
    }else if(element>tree->element){
        tree->right = AVLInsert(tree->right,element);
        //判断平衡因子是否等于2
        if(getHeight(tree->right)-getHeight(tree->left) == 2){
            if(element>tree->right->element){//element往tree的右子树的右子树插入导致平衡因子大于2，进行RR调整
                tree = singleRightRatation(tree);
            }else{//element往tree的右子树的左子树插入导致平衡因子大于2，进行RL调整
                tree = doubleRightLeftRatation(tree);
            }
        }
    }/* else 如果找到了，就不进行插入*/

    tree->treeHeight = getMaxValue(getHeight(tree->left),(getHeight(tree->right)))+1;
    return tree;
}


void main(){
    printf("
==========普通插入=====================================
");
    int findElement=33;
    int deleteData=41;
    pTree tree=insert(NULL,30);
    tree=insert(tree,15);
    tree=insert(tree,41);
    tree=insert(tree,33);
    tree=insert(tree,50);
    tree=insert(tree,35);
    preOrderTraversal(tree);
    printf("
");
    printf("The find element is:%d,the result is %d 
",findElement,find(findElement,tree)->element);
    printf("The min element:%d
",getMinElement(tree)->element);
    printf("The max element:%d
",getMaxElement(tree)->element);
    //printf("delete the elemet %d
",deleteData);
    //deleteElement(tree,deleteData);
    printf("
ordinary tree preOrder
");
    preOrderTraversal(tree);

    printf("
==========AVL插入=====================================
");

    pTree AVLTree=AVLInsert(NULL,30);
    AVLTree=AVLInsert(AVLTree,15);
    AVLTree=AVLInsert(AVLTree,41);
    AVLTree=AVLInsert(AVLTree,33);
    AVLTree=AVLInsert(AVLTree,50);
    AVLTree=AVLInsert(AVLTree,35);
    printf("
");
    printf("The find element is:%d,the result is %d 
",findElement,find(findElement,AVLTree)->element);
    printf("The min element:%d
",getMinElement(AVLTree)->element);
    printf("The max element:%d
",getMaxElement(AVLTree)->element);
    //printf("delete the elemet %d
",deleteData);
    //deleteElement(AVLTree,deleteData);
     printf("
AVL tree preOrder
");
    preOrderTraversal(AVLTree);

}

依次插入 30 15 41 33 50 35

则

这个和程序运行的结果是一致的：