平衡二叉树代码实现（高效非递归方式）

HSS521314
已于 2024-07-09 21:09:34 修改
阅读量468
点赞数 6
文章标签：算法数据结构 c++
于 2024-05-01 22:08:34 首次发布
本文链接：https://blog.csdn.net/HSS521314/article/details/138380774
版权
#include<stdio.h>
#include<time.h>
#include<malloc.h>
#include<stdbool.h>
//节点结构体
typedef struct TreeNode
{
    int id;
    int Height;
    void* data;
    struct TreeNode* parent;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;
//获得节点高度
static inline int Get_Node_Height(TreeNode* Node)
{
    return Node != NULL ? Node->Height : 0;
}
//获得左右子树中最大高度
static inline int MaxHeight_RL(TreeNode* Node)
{
    int Left_Height = Get_Node_Height(Node->left);
    int Right_Height = Get_Node_Height(Node->right);
    return  Left_Height > Right_Height ? Left_Height : Right_Height;
}
//节点右旋
static inline void L_L(TreeNode* Node_Left, TreeNode* Node)
{
    TreeNode* parent = Node->parent;
    TreeNode* Node_Left_right = Node_Left->right;
    Node_Left->right = Node;
    Node->parent = Node_Left;
    Node->left = Node_Left_right;
    if (Node_Left_right != NULL)
    {
        Node_Left_right->parent = Node;
    }
    if (parent != NULL)
    {
        if (parent->left == Node)
            parent->left = Node_Left;
        else
            parent->right = Node_Left;
    }
    Node_Left->parent = parent;
}
//节点左旋
static inline void R_R(TreeNode* Node, TreeNode* Node_Right)
{
    TreeNode* parent = Node->parent;
    TreeNode* Node_Right_left = Node_Right->left;
    Node_Right->left = Node;
    Node->parent = Node_Right;
    Node->right = Node_Right_left;
    if (Node_Right_left != NULL)
    {
        Node_Right_left->parent = Node;
    }
    if (parent != NULL)
    {
        if (parent->left == Node)
            parent->left = Node_Right;
        else
            parent->right = Node_Right;
    }
    Node_Right->parent = parent;
}
//LL型调整
static inline TreeNode* Node_LL(TreeNode* Node)
{
    TreeNode* left = Node->left;
    L_L(left, Node);
    Node->Height = MaxHeight_RL(Node) + 1;
    left->Height = MaxHeight_RL(left) + 1;
    return left;
}
//RR型调整
static inline TreeNode* Node_RR(TreeNode* Node)
{
    TreeNode* right = Node->right;
    R_R(Node, right);
    Node->Height = MaxHeight_RL(Node) + 1;
    right->Height = MaxHeight_RL(right) + 1;
    return right;
}
//LR型调整
static inline TreeNode* Node_LR(TreeNode* Node)
{
    TreeNode* left = Node->left;
    TreeNode* left_right = left->right;
    R_R(left, left_right);
    L_L(left_right, Node);
    left->Height = MaxHeight_RL(left) + 1;
    Node->Height = MaxHeight_RL(Node) + 1;
    left_right->Height = MaxHeight_RL(left_right) + 1;
    return left_right;
}
//RL型调整
static inline TreeNode* Node_RL(TreeNode* Node)
{
    TreeNode* right = Node->right;
    TreeNode* right_left = right->left;
    L_L(right_left, right);
    R_R(Node, right_left);
    right->Height = MaxHeight_RL(right) + 1;
    Node->Height = MaxHeight_RL(Node) + 1;
    right_left->Height = MaxHeight_RL(right_left) + 1;
    return right_left;
}
//创建节点
static TreeNode* CreateNode(int id, void* data)
{
    TreeNode* Node = (TreeNode*)malloc(sizeof(TreeNode));
    if (Node != NULL)
    {
        Node->id = id;
        Node->data = data;
        Node->Height = 1;
        Node->parent = NULL;
        Node->left = NULL;
        Node->right = NULL;
    }
    return Node;
}
//判断节点是否平衡
static inline bool Balance(TreeNode* Node)
{
    int flat = Get_Node_Height(Node->left) - Get_Node_Height(Node->right);
    return flat>1||flat<-1 ? true:false;
}
//调整节点
static TreeNode* AdjustNode(TreeNode* Node)
{
    TreeNode* Head = NULL;
    TreeNode* Temp = Node;
    while (Temp != NULL)
    {
        if (Balance(Temp))
        {   //不平衡调整
            if (Get_Node_Height(Temp->left) > Get_Node_Height(Temp->right))
            {   //L
                if (Get_Node_Height(Temp->left->right)> Get_Node_Height(Temp->left->left))
                    Temp = Node_LR(Temp);//L+R
                else
                    Temp = Node_LL(Temp);//L+L
            }
            else
            {   //R
                if (Get_Node_Height(Temp->right->left)> Get_Node_Height(Temp->right->right))
                    Temp = Node_RL(Temp);//R+L
                else
                    Temp = Node_RR(Temp);//R+R           
            }
        }
        else
        {
            int Height = MaxHeight_RL(Temp) + 1;
            if (Temp->Height == Height)
                return Temp->parent == NULL ? Temp : NULL;
            else
                Temp->Height = Height;
        }
        Head = Temp;
        Temp = Temp->parent;
    }
    return Head;
}
//插入节点
extern bool Add_Node(TreeNode** Node, int id, void* data)
{
    TreeNode* Add = CreateNode(id, data);
    if (Add == NULL)
        return false;
    if (*Node == NULL)
    {
        *Node = Add;
        return  true;
    }
    TreeNode* Temp = *Node;
    while (true)
    {
        if (Temp->id == id)
        {
            free(Add);
            return false;
        }
        else if (Temp->id > id)
        {
            if (Temp->left == NULL)
            {
                Temp->left = Add;
                break;
            }
            else
                Temp = Temp->left;
        }
        else
        {
            if (Temp->right == NULL)
            {
                Temp->right = Add;
                break;
            }
            else
                Temp = Temp->right;
        }
    }
    Add->parent = Temp;
    if (Temp->left == NULL || Temp->right == NULL)
    {
        TreeNode* Head = AdjustNode(Temp);
        if (Head != NULL)
            *Node = Head;
    }
    return true;
}
//查找节点
extern inline TreeNode* Find_Node(TreeNode* Node, int id)
{
    while (Node != NULL)
    {
        if (Node->id == id)
            return Node;
        else if (Node->id > id)
            Node = Node->left;
        else
            Node = Node->right;
    }
    return Node;
}
//得到树的最右节点
static inline TreeNode* Get_Tree_Left(TreeNode* Left)
{
    while (Left->left != NULL)
    {
        Left = Left->left;
    }
    return Left;
}
//得到树的最左节点
static inline TreeNode* Get_Tree_Right(TreeNode* Right)
{
    while (Right->right != NULL)
    {
        Right = Right->right;
    }
    return Right;
}
//复制节点
static inline void Copy_Node(TreeNode* Node_1, TreeNode* Node_2)
{
    Node_1->id = Node_2->id;
    Node_1->data = Node_2->data;
}
//删除节点
extern bool Del_Node(TreeNode** Node, int id)
{
    TreeNode* Del = Find_Node(*Node, id);
    if (Del == NULL)
        return false;
    TreeNode* parent = NULL;
    if (Del->left == NULL && Del->right == NULL)
    {//当子孩子都为空的情况
        parent = Del->parent;
        if (parent != NULL)
        {
            if (parent->left == Del)
                parent->left = NULL;
            else
                parent->right = NULL;
        }
        else
        {
            *Node = NULL;
             return true;
        }
    }
    else
    {
        TreeNode* replace = NULL;
        if (Get_Node_Height(Del->left) < Get_Node_Height(Del->right))
            replace = Get_Tree_Left(Del->right);
        else
            replace = Get_Tree_Right(Del->left);
        parent = replace->parent;
        Copy_Node(Del, replace);
        if (replace->left != NULL || replace->right != NULL)
        {//删除的节点存在一个为空的情况下
            if (replace->left==NULL)
            {    
                Copy_Node(replace, replace->right);
                Del = replace->right;
                replace->right = NULL;
            }
            else
            {
                Copy_Node(replace, replace->left);
                Del = replace->left;
                replace->left = NULL;
            }
            parent = replace;
        }
        else
        {
            if (parent->left == replace)
                parent->left = NULL;
            else
                parent->right = NULL;
            Del = replace;
        }
    }
    free(Del);
    TreeNode* Head = AdjustNode(parent);
    if (Head != NULL)
        *Node = Head;
    return true;
}
extern void Destroy_Tree(TreeNode* Node)
{
    if (Node == NULL)
        return;
    Destroy_Tree(Node->left);
    Destroy_Tree(Node->right);
    free(Node);
}
int main()
{
    const int Num = 10000000;
    TreeNode* Node = NULL;
    srand(time(NULL));
    int cout=0;
    clock_t t = clock();
    for (int i=0; i< Num; i++)
    {   //插入顺序数测试
        if(Add_Node(&Node,i, NULL))
        cout++;
    }
    printf("创建%d个节点用时：%dus\n",cout,clock() - t);
    cout=0;
    t=clock();
    for(int i=0; i<Num; i++)
    {
        if(Find_Node(Node,i))
        cout++;
    }
    printf("单个遍历%d个节点有节点用时：%dus\n",cout,clock()-t);
    cout=0;
    t = clock();
    for (int i = 0; i < Num; i++)
    {
        if(Del_Node(&Node, i))
        cout++;
    }
    printf("删除%d个节点用时：%dus\n",cout, clock() - t);
    return 0;
}