平衡二叉树的创建、插入和删除操作 C语言实现

_lWill

于 2024-03-24 18:40:13 发布

阅读量1.3k

点赞数 54

分类专栏：数据结构与算法文章标签： c语言算法数据结构

本文链接：https://blog.csdn.net/jiekegiao/article/details/136975044

版权

数据结构与算法专栏收录该内容

12 篇文章 0 订阅

订阅专栏

介绍

当二叉搜索树中的节点按照某种顺序插入，导致树的一边过长，另一边过短时，树就会变得不平衡。不平衡的二叉搜索树在插入、删除和查找操作时，效率会降低，最坏情况下会变成一条线性链表，时间复杂度变为O(n)。

为了解决这一问题，G. M. Adelson-Velsky 和 Evgenii Landis 二叉搜索树进行优化，提出了平衡二叉树这一概念

平衡二叉树，也称为AVL树或高度平衡的二叉搜索树。在平衡二叉树中，任何一个节点的两个子树的高度差都不超过1，这使得它特别适合用于排序和查找操作。

平衡二叉树的节点除了包含值、左子节点和右子节点的指针，还增加了一个高度值。每个节点的高度表示该节点的子树的高度，用于计算平衡因子（balance factor），即该节点的左子树的高度减去右子树的高度。平衡因子用于判断该节点是否平衡，若平衡因子的绝对值大于1，则该节点不平衡，需要进行旋转操作进行平衡。

平衡二叉树的插入和删除操作可能会破坏树的平衡性，因此，在插入或删除节点后，需要通过旋转操作来恢复平衡。常见的旋转操作有四种：左旋和右旋，以及它们的逆操作。

平衡二叉树是一种自平衡的二叉搜索树，它的插入、删除和查找操作的时间复杂度均为O(log n)。

数据结构

struct _AVLNode{
    int data;
    int height;
    struct _AVLNode *left;
    struct _AVLNode *right;
};
typedef struct _AVLNode LAVLNode;

struct _AVLTree{
    LAVLNode *pRoot;
    int size; //size of tree
};
typedef struct _AVLTree LAVLTree;

// 创建一个AVL树节点
LAVLNode* createNode(int data){
    
    LAVLNode* pNode = (LAVLNode*)malloc(sizeof(LAVLNode));

    if (pNode != NULL) {
        pNode->data = data;
        pNode->height = 1; //设置平衡因子为0
        pNode->left = NULL;
        pNode->right = NULL;
    }

    return pNode;
}

// 创建一个AVL树
LAVLTree createAVLTree(){

    LAVLTree tree;

    tree.pRoot = NULL;
    tree.size  = 0;

    return tree;
}


//获得节点高度
int getAVLNodeHeight(LAVLNode* pNode){
    if(pNode==NULL)
        return 0;
    else
        return pNode->height;
}

//计算节点高度
int calAVLNodeHeight(LAVLNode* pNode){

    int left_height,right_height;
    left_height=getAVLNodeHeight(pNode->left);
    right_height=getAVLNodeHeight(pNode->right);

    pNode->height=(left_height>right_height?left_height:right_height)+1;

    return pNode->height;
}

节点高度的计算方法

1.叶子节点的高度为1

2.节点的高度 = 左右子节点最高高度+1

3.当一个节点的两棵子树的高度差大于 1 时，这个树就失衡了

平衡二叉树节点的插入操作

平衡二叉树在插入过程中的操作步骤与二叉搜索树基本相同，只是在插入节点后需要对树的平衡性进行维护。

平衡二叉树的插入过程如下：

按照二叉搜索树的规则插入节点。
1. 首先，从根节点开始，将新节点的值与当前节点的值进行比较。
2. 如果新节点的值小于当前节点的值，并且当前节点的左子节点为空，将新节点插入到当前节点的左子节点位置；否则，将当前节点左子节点作为新的当前节点，继续比较。
3. 如果新节点的值大于当前节点的值，并且当前节点的右子节点为空，将新节点插入到当前节点的右子节点位置；否则，将当前节点右子节点作为新的当前节点，继续比较。
4. 重复上述步骤，直到找到一个合适的插入位置。
计算新插入节点的平衡因子（左子树高度 - 右子树高度）。
如果新插入节点的平衡因子绝对值大于1，进行旋转操作以维护树的平衡性。

具体旋转操作包括：
- 左旋
- 右旋
- 左右旋（先对节点的左孩子进行左旋，再对它进行右旋）
- 右左旋（先对节点的右孩子进行右旋，再对它进行左旋）
重复上述步骤，直到整棵树重新平衡。

左旋

1.节点的右孩子替代此节点位置

2.右孩子的左子树变为该节点的右子树

3.节点本身变为右孩子的左子树

图例

代码实现

void rotateLeft(LAVLNode**ppNode){
    LAVLNode* temp = *ppNode;
    *ppNode = temp->right;
    temp->right = (*ppNode)->left;
    (*ppNode)->left = temp;
    calAVLNodeHeight(temp);
    calAVLNodeHeight(*ppNode);
}

右旋

1.节点的左孩子代替此节点位置

2.节点的左孩子的右子树变为节点的左子树

3.将此节点作为左孩子节点的右子树。

图例

代码实现

void rotateRight(LAVLNode**ppNode){
    LAVLNode* temp = *ppNode;
    *ppNode = temp->left;
    temp->left=(*ppNode)->right;
    (*ppNode)->right = temp;
    calAVLNodeHeight(temp);
    calAVLNodeHeight(*ppNode);
}

左右旋

先对节点的左孩子进行左旋，再对它进行右旋

图例

代码实现

rotateLeft(&(*ppNode)->left);

rotateRight(ppNode);

右左旋

先对节点的右孩子进行右旋，再对它进行左旋

图例

代码实现

rotateRight(&(*ppNode)->right);

rotateLeft(ppNode);

插入代码

//平衡二叉树插入回调
LAVLNode* insertAVLNodeRecursive(LAVLNode **ppNode, int data){
    LAVLNode * newNode=NULL;
    // 插入一个节点到AVL树
    if(*ppNode == NULL){
        newNode = createNode(data);
        *ppNode = newNode;     
    }
    else if(data < (*ppNode)->data){
        newNode = insertAVLNodeRecursive(&(*ppNode)->left, data);
        // 计算平衡因子
        int balance = getAVLNodeHeight((*ppNode)->left) - getAVLNodeHeight((*ppNode)->right);
        if(balance > 1){
            // 左子树比右子树高
            if(data < (*ppNode)->left->data){
                // 插入的节点在左子树的左子树
                rotateRight(ppNode);
            }else{
                // 插入的节点在左子树的右子树
                rotateLeft(&(*ppNode)->left);
                rotateRight(ppNode);
            }
        }
    }
    else if(data > (*ppNode)->data){
        newNode = insertAVLNodeRecursive(&(*ppNode)->right, data);
        // 计算平衡因子
        int balance = getAVLNodeHeight((*ppNode)->left) - getAVLNodeHeight((*ppNode)->right);
        if(balance < -1){
            // 右子树比左子树高
            if(data > (*ppNode)->right->data){
                // 插入的节点在右子树的右子树
                rotateLeft(ppNode);
            }else{
                // 插入的节点在右子树的左子树
                rotateRight(&(*ppNode)->right);
                rotateLeft(ppNode);
            }
            
        }
    }
    else{
        //不允许插入重复的数据
        //return *ppNode;
        newNode = NULL;
    }
    
    //计算高度
    calAVLNodeHeight(*ppNode);
    return newNode;

}
//平衡二叉树的插入
LAVLNode* insertAVLNode(LAVLTree *pTree, int data){
    LAVLNode* newNode = insertAVLNodeRecursive(&pTree->pRoot,data);
    if(newNode){
        pTree->size++;
    }
    return newNode;
}

平衡二叉树节点的删除操作

删除节点：首先按照二叉搜索树的规则删除节点。
1. 如果待删除节点有左右子树，则找到其右子树中的最小值节点（或左子树中的最大值节点），将其值复制到待删除节点，然后删除那个最小（或最大）值节点。
2. 如果待删除节点仅有左子树或仅有右子树，则待删除节点的左子树或右子树取代待删除节点位置
3. 如果待删除节点为叶子节点，则直接删除
平衡树：在删除节点后，可能需要对树进行平衡操作。
递归平衡：在完成上述操作后，需要递归地对受影响的子树进行平衡操作。

//找到当前平衡子树的最大值，释放最大值节点，并返回最大值
int findMaxValue(LAVLNode** ppNode){
    if(ppNode==NULL||*ppNode==NULL)
        return 0;

    int ret;

    if((*ppNode)->right==NULL){
        ret=(*ppNode)->data; 
        LAVLNode* curnode = *ppNode;
        *ppNode=curnode->left;
        free(curnode);
    }else{
        ret=findMaxValue(&(*ppNode)->right);
        calAVLNodeHeight(*ppNode);
    }
    
    return ret;

}

//删除(删除成功返回1 失败返回0)
int deleteAVLNodeRecursive(LAVLNode **ppNode,int data){
    if(*ppNode==NULL){
        return 0;
    }

    int ret;
    int curdata = (*ppNode)->data;
    LAVLNode* curnode = *ppNode; 

    if(data==curdata){
        if(curnode->left==NULL&&curnode->right==NULL){
            // printf("TWO NULL\n");
            free(*ppNode);
            *ppNode=NULL;
            return 1;
        }else{
            if(curnode->left==NULL){
                // printf("LEFT NULL\n");
                *ppNode=curnode->right;
                free(curnode);
            }else if(curnode->right==NULL){
                // printf("RIGHT NULL\n");
                *ppNode=curnode->left;
                free(curnode);
            }else{
                // printf("NOT NULL\n");
                curnode->data = findMaxValue(&curnode->left);
            }
        }
        
        
        
    }else if(data>curdata){
        ret = deleteAVLNodeRecursive(&(*ppNode)->right,data);

        // 计算平衡因子
        int balance = getAVLNodeHeight((*ppNode)->left) - getAVLNodeHeight((*ppNode)->right);
        if(balance > 1){
            // 左子树比右子树高
            if(getAVLNodeHeight(curnode->left->left)>=getAVLNodeHeight(curnode->left->right)){
                rotateRight(ppNode);
            }else{
                rotateLeft(&(*ppNode)->left);
                rotateRight(ppNode);
            }
        }

    }else if(data<curdata){
        ret = deleteAVLNodeRecursive(&(*ppNode)->left,data);

        int balance = getAVLNodeHeight((*ppNode)->left) - getAVLNodeHeight((*ppNode)->right);
        if(balance < -1){
            // 左子树比右子树高
            // printf("left:%d",curnode->left);
            if(getAVLNodeHeight(curnode->right->left)<=getAVLNodeHeight(curnode->right->right)){
                rotateLeft(ppNode);
            }else{
                rotateRight(&(*ppNode)->right);
                rotateLeft(ppNode);
            }
        }

    }

    calAVLNodeHeight((*ppNode));

    return ret;

}

int deleteAVLNode(LAVLTree*pTree,int data){
    if(pTree->pRoot==NULL||pTree->size==0)
        return -1;

    return deleteAVLNodeRecursive(&pTree->pRoot,data);
    
}

平衡二叉树查找功能实现代码

//查找
LAVLNode*findLAVLNodeRecursive(const LAVLNode *pNode,const int data){
    if(pNode==NULL)
        return NULL;
    
    LAVLNode *goalnode = NULL;

    if(pNode->data==data){
        goalnode = pNode;
    }else if(data>pNode->data){
        printf("data :%d > node :%d  go right\n",data,pNode->data);
        goalnode = findLAVLNodeRecursive(pNode->right,data);
    }else if(data<pNode->data){
        printf("data :%d < node :%d  go left\n",data,pNode->data);
        goalnode = findLAVLNodeRecursive(pNode->left,data);
    }

}

LAVLNode*findLAVLNode(LAVLTree*pTree,const int data){
    if(pTree==NULL||pTree->size<=0)
        return NULL;
    return findLAVLNodeRecursive(pTree->pRoot,data);
}

_lWill

关注

54
点赞
踩
41

收藏

觉得还不错? 一键收藏
1
评论
平衡二叉树的创建、插入和删除操作 C语言实现

当二叉搜索树中的节点按照某种顺序插入，导致树的一边过长，另一边过短时，树就会变得不平衡。不平衡的二叉搜索树在插入、删除和查找操作时，效率会降低，最坏情况下会变成一条线性链表，时间复杂度变为O(n)。为了解决这一问题，和二叉搜索树进行优化，提出了平衡二叉树这一概念平衡二叉树，也称为AVL树或高度平衡的二叉搜索树。在平衡二叉树中，任何一个节点的两个子树的高度差都不超过1，这使得它特别适合用于排序和查找操作。平衡二叉树的节点除了包含值、左子节点和右子节点的指针，还增加了一个高度值。
复制链接

扫一扫