使用C语言代码实现平衡二叉树-电子发烧友网

1. 什么是平衡二叉树

平衡二叉树，我们也称【二叉平衡搜索树/AVL】,树中任何节点的两个子树的高度最大差别为1，巴拉巴拉。。。(https://baike.baidu.com/item/AVL树/10986648?fr=aladdin)

但是有个注意的点: 平衡二叉树的前提是二叉排序树(https://baike.baidu.com/item/二叉搜索树/7077855?fr=aladdin)

这篇博客主要总结平衡二叉树，所以，二叉排序树知识不会提及，但是会用到。

如果想要看排序二叉树调整为平衡二叉树旋转相关内容的，调整至第5节。

平衡二叉树

非平衡二叉树

最小不平衡子树节点为 130

左子树深度为 1，右子树深度为3 ，其差值大于1，所以不平衡

2. 如何判断二叉树最小不平衡子树

最小不平衡子树为 130 这颗子树(黄色标注)

判定最小不平衡子树的关键就在于，判断这棵树的左子树和右字数深度之差是否大于1，若大于1 ，则证明该树不平衡

检查二叉树是否平衡函数代码实现

typedef struct {
        int data; // 数据节点
        struct TreeNode *left; // 指向左子树
        struct TreeNode *right; // 指向右子树
} TreeNode , *PTreeNode;

// 记录平衡二叉树
bool BalanceTrue = false;
// 最小不平衡子树地址
TreeNode *rjt = NULL;

// 检查二叉树是否平衡，若不平衡 BalanceTrue 为 true
int checkTreeBalance(TreeNode *root) {
        if (NULL == root) { return 0; }
        int x = checkTreeBalance(root->left);
        int y = checkTreeBalance(root->right);

        // 若检测到最小不平衡二叉树后，不进行后面的检查
        if (BalanceTrue) return 0;
    
        int xx = abs(x-y);

        if (xx > 1) {
                // 左子树 和 右子树 相差大于1 ， 二叉树不平衡
                BalanceTrue = true;
                rjt = root;
        }
         
        return (x>y?x+1:y+1);
}

程序执行结果

# gcc -w -g -std=c11 BalanceTree.c 
# 
# ./a.out 
当前二叉树遍历
前序遍历: 580    130     80      160     150     158     210     1590    900     2100    1900
中序遍历: 80     130     150     158     160     210     580     900     1590    1900    2100
二叉树不平衡，不平衡子树根节点为: 130
#

3. 二叉树不平衡情况

在一颗平衡二叉树的前提下，插入和删除一个节点，都有可能会引起二叉树不平衡，不平衡的情况主要有以下四种

左左更高

左右更高

右左更高

右右更高

4. 判断不平衡二叉树哪边高

如上图红色所示，可以先根据最小不平衡二叉树左子树或者右子树高，上图所示，为右子树高，则将最小不平衡二叉树的右子树作为树根节点，继续判断子树的左子树或者右子树高。
比如上图的结果是右左较高，若进行调整的话，为先让不平衡子树右节点的树先向右旋转，然后再向左旋转。

判断不平衡二叉树哪边高代码实现

typedef struct {
        int data; // 数据节点
        struct TreeNode *left; // 指向左子树
        struct TreeNode *right; // 指向右子树
} TreeNode , *PTreeNode;

// 记录平衡二叉树
bool BalanceTrue = false;
// 最小不平衡子树地址
TreeNode *rjt = NULL;

// 返回二叉树树高
int treeHeight(TreeNode *root) {
        if (NULL == root) return 0;
        int ll = treeHeight(root->left);
        int rr = treeHeight(root->right);
        return (ll>rr?ll+1:rr+1);
}

int main() {
    /*  构建二叉树
    判断平衡，获取最小不平衡子树， 将数据存入 rjt 中
    输出二叉树 前序/中序
    */
    if (BalanceTrue) {
        printf("二叉树不平衡，不平衡子树根节点为: %d
",rjt->data);
    } else {
        return 0;
    };


    int ll = treeHeight(rjt->left);
    int rr = treeHeight(rjt->right);
    if (1 < ll - rr) {
        printf("左子树高
");
        TreeNode *rjt_ll = rjt->left;

        int child_ll = treeHeight(rjt_ll->left);
        int child_rr = treeHeight(rjt_ll->right);
        if (child_ll > child_rr) {
            printf("左子树更高
");
        } else if (child_rr > child_ll) {
            printf("右字数更高");
        }

    } else if (1 <  rr - ll) {
        printf("右子数高
");
        TreeNode *rjt_rr = rjt->right;

        int child_ll = treeHeight(rjt_rr->left);
        int child_rr = treeHeight(rjt_rr->right);
        if (child_ll > child_rr) {
            printf("左子树更高
");
        } else if (child_rr > child_ll) {
            printf("右字数更高");
        }

    }

    return 0;
}

输出

# gcc BalanceTree.c -w -g -std=c11
# 
# ./a.out 
当前二叉树遍历
前序遍历:130    80      160     150     158     210
中序遍历:80     130     150     158     160     210
二叉树不平衡，不平衡子树根节点为: 130
右子数高
左子树更高
#

5. 如何调整平衡二叉树

所谓的旋转，其实是修改指针指向的值，仅此而已。

二叉树不平衡有四种情况

左左更高

原始二叉树，若要调整为平衡二叉树，需要整棵树向右旋转

调整1:整棵树向右旋转

左右更高

原始二叉树，若要调整为平衡二叉树，需要先让不平衡子树左节点先向左旋转，然后再向右旋转

调整1: 先让不平衡子树左节点的树先向左旋转

调整2:整棵树向右

右左更高

原始二叉树，若要调整为平衡二叉树，需要先让不平衡子树右节点的树先向右旋转，然后再向左旋转

调整1: 先让不平衡子树右节点的树先向右旋转

调整2:整棵树向左

右右更高

原始二叉树，若要调整为平衡二叉树，需要整棵树向左旋转

调整1:整棵树向左旋转

全部代码

# include 
# include 
# include 
# include 

typedef struct {
int data; // 数据节点
struct TreeNode *left; // 指向左子树
struct TreeNode *right; // 指向右子树
} TreeNode , *PTreeNode;

// 记录平衡二叉树
bool BalanceTrue = false;
// 最小不平衡子树地址
TreeNode *rjt = NULL;

// 检查二叉树是否平衡，若不平衡 BalanceTrue 为 true
int checkTreeBalance(TreeNode *root) {
if (NULL == root) { return 0; }
int x = checkTreeBalance(root->left);
int y = checkTreeBalance(root->right);

// 若检测到最小二叉树后，不进行后面的检查
if (BalanceTrue) return 0;
int xx = abs(x-y);

if (xx > 1) {
// 左子树 和 右子树 相差大于1 ， 二叉树不平衡
BalanceTrue = true;
rjt = root;
}
 
return (x>y?x+1:y+1);
}

// 返回二叉树树高
int treeHeight(TreeNode *root) {
if (NULL == root) return 0;
int ll = treeHeight(root->left);
int rr = treeHeight(root->right);
return (ll>rr?ll+1:rr+1);
}

// 父节点查询
TreeNode* queryTopData(TreeNode *root,int data) {
// 空地址异常抛出
if (NULL == root) return NULL;

// top: 父节点 ，如果为Null, 该节点为父节点
// tmp: 遍历查询节点 
TreeNode *top = NULL;
TreeNode *tmp = root;

while (tmp != NULL) {
if (data == tmp->data) {
// 节点为 返回Null
if (NULL == top) return NULL;
return top;
}

top = tmp;
if (data > tmp->data) {
tmp = tmp->right;
} else if (data < tmp->data) {
tmp = tmp->left;
}
}
return NULL;
}

// 左左旋转
//
// 不平衡二叉树
//       70
//      /   
//    50    80
//   /      
//  40  60
//  /
// 30
//
// 旋转后平衡二叉树(向右旋转)
//
//    50
//  /   
// 40    70
// /     /  
//30   60    80
//
bool turnLL(TreeNode **root , TreeNode *notBalanceRoot) {

if ((*root) != notBalanceRoot) {
printf("左左旋转,非根节点
");
// 非根节点
TreeNode *lleft = notBalanceRoot->left;
TreeNode *lright = lleft->right;

// 查找父节点
TreeNode *fdata = queryTopData((*root),notBalanceRoot->data);
if (NULL == fdata) return false;

lleft->right = notBalanceRoot;
notBalanceRoot->left = lright;

if (notBalanceRoot == fdata->left) {
fdata->left = lleft;
} else if (notBalanceRoot == fdata->right) {
fdata->right = lleft;
}
return true;

} else {
// 根节点
printf("左左旋转,是根节点
");
TreeNode *lleft = notBalanceRoot->left;
TreeNode *absroot = lleft;
TreeNode *lright = lleft->right;


lleft->right = notBalanceRoot;
notBalanceRoot->left = lright;

(*root) = absroot;
return true;
}

}

// 左右旋转
//不平衡二叉树
//      70
//     /   
//    50    80
//    /     
//   40 60
//  /   
// 55
//
//左子树向左
//      70
//     /   
//    60    80
//    /
//   50
//  /      
// 40  55
//                                                           
//                                                                   
// 整棵树向右
// 
//     60
//    /   
//   50    70
//  /       
// 40  55    80
//
bool turnLR(TreeNode **root , TreeNode *notBalanceRoot) {
if ((*root) != notBalanceRoot) {
printf("左右旋转，非根节点");

TreeNode *lleft = notBalanceRoot->left;
TreeNode *leftRight = lleft->right;
TreeNode *leftRightLeft = leftRight->left;

// 第一次调整
leftRight->left = lleft;
lleft->right = leftRightLeft;
notBalanceRoot->left = leftRight;


// 查找父节点
TreeNode *fdata = queryTopData((*root),notBalanceRoot->data);
//if (NULL != fdata) printf("fdata: %d
",fdata->data);

// 第二次调整
lleft = notBalanceRoot->left;
leftRight = lleft->right;

lleft->right = notBalanceRoot;
notBalanceRoot->left = leftRight;


if (notBalanceRoot == fdata->left) {
fdata->left = lleft;
} else if (notBalanceRoot == fdata->right) {
fdata->right = lleft;
}
} else {
printf("左右旋转，是根节点
");

TreeNode *lleft = notBalanceRoot->left;
TreeNode *leftRight = lleft->right;
TreeNode *leftRightLeft = leftRight->left;

// 第一次调整
leftRight->left = lleft;
lleft->right = leftRightLeft;
notBalanceRoot->left = leftRight;

// 第二次调整
lleft = notBalanceRoot->left;
leftRight = lleft->right;

lleft->right = notBalanceRoot;
notBalanceRoot->left = leftRight;

(*root) = lleft;
}
}

// 右左旋转
//不平衡二叉树
//   70
//  /  
// 50   80
//     /  
//    75  88
//     
//     77
//
//左子树向右
//   70
//  /  
// 50   75
//     /  
//    77  80
//         
//         88
//                                                                                                           
//                                                                                                                  
//                                                                                                                      
//整棵树向左
//     75
//    /  
//   70  80
//  /      
// 50  77  88 
//
bool turnRL(TreeNode **root , TreeNode *notBalanceRoot) {
TreeNode *rright = notBalanceRoot->right;
TreeNode *rightLeft = rright->left;
TreeNode *rightLeftRight = rightLeft->right;

// 第一次调整
rightLeft->right = rright;
rright->left = rightLeftRight;
notBalanceRoot->right = rightLeft;

// 查找父节点
TreeNode *fdata = queryTopData((*root),notBalanceRoot->data);
//if (NULL != fdata) printf("fdata: %d
",fdata->data);

// 第二次调整
rright = notBalanceRoot->right;
rightLeft = rright->left;

rright->left = notBalanceRoot;
notBalanceRoot->right = rightLeft;

if ((*root) != notBalanceRoot) {
printf("右左旋转，非根节点
");
if (notBalanceRoot == fdata->left) {
fdata->left = rright;
} else if (notBalanceRoot == fdata->right) {
fdata->right = rright;
}

} else {
printf("右左旋转，是根节点
");
(*root) = rright;
}
}

// 右右旋转
// 
// 不平衡二叉树
//  70
// /  
//50   80
//    /  
//   75  88
//      /
//     85
//
//
//
//向左旋转
//    80
//   /  
//  70   88
// /     /  
//50  75 85  
bool turnRR(TreeNode **root , TreeNode *notBalanceRoot) {
if ((*root) != notBalanceRoot) {
printf("右右旋转,非根节点");
TreeNode *rright = notBalanceRoot->right;
TreeNode *rleft = rright->left;

// 查找父节点
TreeNode *fdata = queryTopData((*root),notBalanceRoot->data);
if (NULL != fdata) printf("fdata: %d
",fdata->data);

                rright->left = notBalanceRoot;
                notBalanceRoot->right = rleft;

                if (notBalanceRoot == fdata->left) {
                        fdata->left = rright;
                } else if (notBalanceRoot == fdata->right) {
                        fdata->right = rright;
                }

} else {
// 右右旋转，是根节点
printf("右右旋转,是根节点
");
TreeNode *rright = notBalanceRoot->right;
TreeNode *absroot = rright;
TreeNode *rleft = rright->left;

rright->left = notBalanceRoot;
notBalanceRoot->right = rleft;

(*root) = absroot;

}
}

// 二叉树前序遍历
void Print1(TreeNode *root) {
if (NULL == root) return;
printf("%d	",root->data);
Print1(root->left);
Print1(root->right);
}

// 二叉树中序遍历
void Print2(TreeNode *root) {
if (NULL == root) return;
Print2(root->left);
printf("%d	",root->data);
Print2(root->right);
}

// 二叉树后续遍历
void Print3(TreeNode *root) {
if (NULL == root) return;
Print3(root->left);
Print3(root->right);
printf("%d	",root->data);
}

// 插入二叉树节点
TreeNode* addNode(TreeNode *root,int data) {
if (NULL == root) {
// 头节点插入
TreeNode *Node = (TreeNode *)malloc(sizeof(TreeNode));
if (NULL == Node) {
printf("新节点申请内存失败
");
return NULL;
}
Node->data = data;

return Node;
}

TreeNode *tmp = root;
TreeNode *top = NULL;

// 找到合适的最尾巴节点
while (NULL != tmp) {
top = tmp;
if (tmp->data == data) {
printf("已经存在该节点，节点地址: %p
",tmp);
return root;
}
if (tmp->data < data) {
tmp = tmp->right;
} else if (tmp->data > data) {
tmp = tmp->left;
}
}

TreeNode *Node = (TreeNode *)malloc(sizeof(TreeNode));
Node->data = data;
if (NULL == Node) {
printf("申请新节点内存失败
");
return root;
}

// 链接节点
if (data > top->data) {
top->right = Node;
} else if (data < top->data) {
top->left = Node;
}

return root;
}


// 删除二叉排序树节点
bool DeleteTreeNode(TreeNode **TreeRoot,int data) {
if (NULL == (*TreeRoot)) return false;

printf("删除节点: %d
",data);

TreeNode *tmp = (*TreeRoot);
TreeNode *top = NULL;

while (tmp != NULL) {
if (tmp->data == data) {
// 叶子节点
if ((NULL == tmp->left) && (NULL == tmp->right)) {
// 叶子节点
if (NULL == top) {
// 仅有根节点的叶子节点
free(tmp);
return true;
} else {
// 其他的叶子节点
TreeNode *lastNode = top;
if (tmp == lastNode->left) {
lastNode->left = NULL;
} else if (tmp == lastNode->right) {
lastNode->right = NULL;
}
free(tmp);
return true;
}
} else {
// 非叶子节点
// 算法为: 
// 默认算法为: 1.  当删除该节点时，获取该树右子树最左子节点
//             2.  当右子树为空时，此时应该获取左子树最右端子节点

if (NULL != tmp->right) {
// 方案 1
TreeNode *tmp2 = tmp->right;
TreeNode *top2 = NULL;

// 找到最后一个节点
while (tmp2->left != NULL) {
top2 = tmp2;
tmp2 = tmp2->left;
}

// 删除老的节点
tmp->data = tmp2->data;
// 只有右子树节点 没有左子树节点
if (NULL == top2) {
tmp->right = NULL;

} else {
top2->left = NULL;
}
free(tmp2);
} else {
// 方案 2
TreeNode *tmp2 = tmp->left;
TreeNode *top2 = NULL;

// 找到最后一个节点
while (tmp2->right != NULL) {
tmp2 = tmp2->right;
}

// 删除老的节点
tmp->data = tmp2->data;
if (NULL == top2) {
tmp->left = NULL;
} else {
top2->right = NULL;
}
free(tmp2);
}

}
} else {
top = tmp;
if (data > tmp->data) {
tmp = tmp->right;
} else {
tmp = tmp->left;
}
}
}
return false;
}

// 二叉树平衡调整
bool treeBalance(TreeNode **root) {
checkTreeBalance((*root));
while (BalanceTrue) {
printf("二叉树不平衡,最小不平衡子树数据结点: %d
",rjt->data);
TreeNode *tmp;

if (1 < treeHeight(rjt->left) - treeHeight(rjt->right)) {
// 对于不平衡二叉树而言，左子树比右子树高
//
//printf("左
");
if (rjt->left != NULL) {
tmp = rjt->left;
int ll = treeHeight(tmp->left);
int rr = treeHeight(tmp->right);

if (ll > rr) {
// 对于不平衡子树 左子树 而言， 左子树比右子树高
// 左左旋转

turnLL(root,rjt);

} else {
// 对于不平衡子树 左子树 而言， 右子树比左子树高
// 左右旋转
//
turnLR(root ,rjt);
}
} 
} else if (1 < treeHeight(rjt->right) - treeHeight(rjt->left)) {
// 对于不平衡二叉树而言，右子树比左子树高
//
//printf("右
");
if (rjt->right != NULL) {
tmp = rjt->right;
int ll = treeHeight(tmp->left);
int rr = treeHeight(tmp->right);

if (ll > rr) {
//右左旋转
turnRL(root,rjt);
} else {
//右右旋转
turnRR(root,rjt);
}
}
}

BalanceTrue = false;
checkTreeBalance((*root));
printf("二叉树调整平衡后数据结点:
");
printf("前序遍历:");
Print1(*root);
printf("
");
printf("中序遍历:");
Print2(*root);
printf("
");
printf("
");
}

}

int main() {
TreeNode *root = NULL;

printf("平衡二叉树插入测试
");
int nums[] = {65,60,70,55,40,63,69,66,68,77};
int i;
for (i=0;i<sizeof(nums)/sizeof(int);i++) {
printf("插入数据: %d
",nums[i]);

root = addNode(root,nums[i]);
if (NULL == root) {
printf("首节点申请失败"); 
return -1;
}

treeBalance(&root);
sleep(1);

}
printf("
当前二叉树遍历
");
printf("前序遍历:");
Print1(root);
printf("
");
printf("中序遍历:");
Print2(root);
printf("
");
//return 0;

printf("

平衡二叉树删除测试
");

for (i=2;i<5;i++) {
DeleteTreeNode(&root,nums[i]);

treeBalance(&root);
sleep(1);
}

printf("
当前二叉树遍历
");
printf("前序遍历:");
Print1(root);
printf("
");
printf("中序遍历:");
Print2(root);
printf("
");

return 0;
}

程序执行结果

# gcc BalanceTree.c -w -g -std=c11
# 
# ./a.out 
平衡二叉树插入测试
插入数据: 65
插入数据: 60
插入数据: 70
插入数据: 55
插入数据: 40
二叉树不平衡,最小不平衡子树数据结点: 60
左左旋转,非根节点
二叉树调整平衡后数据结点:
前序遍历:65     55      40      60      70
中序遍历:40     55      60      65      70

插入数据: 63
二叉树不平衡,最小不平衡子树数据结点: 65
左右旋转，是根节点
二叉树调整平衡后数据结点:
前序遍历:60     55      40      65      63      70
中序遍历:40     55      60      63      65      70

插入数据: 69
插入数据: 66
二叉树不平衡,最小不平衡子树数据结点: 70
左左旋转,非根节点
二叉树调整平衡后数据结点:
前序遍历:60     55      40      65      63      69      66      70
中序遍历:40     55      60      63      65      66      69      70

插入数据: 68
二叉树不平衡,最小不平衡子树数据结点: 65
右左旋转，非根节点
二叉树调整平衡后数据结点:
前序遍历:60     55      40      66      65      63      69      68      70
中序遍历:40     55      60      63      65      66      68      69      70

插入数据: 77
二叉树不平衡,最小不平衡子树数据结点: 60
右右旋转,是根节点
二叉树调整平衡后数据结点:
前序遍历:66     60      55      40      65      63      69      68      70      77
中序遍历:40     55      60      63      65      66      68      69      70      77


当前二叉树遍历
前序遍历:66     60      55      40      65      63      69      68      70      77
中序遍历:40     55      60      63      65      66      68      69      70      77


平衡二叉树删除测试
删除节点: 70
删除节点: 55
删除节点: 40
二叉树不平衡,最小不平衡子树数据结点: 60
右左旋转，非根节点
二叉树调整平衡后数据结点:
前序遍历:66     63      60      65      69      68      77
中序遍历:60     63      65      66      68      69      77


当前二叉树遍历
前序遍历:66     63      60      65      69      68      77
中序遍历:60     63      65      66      68      69      77
#

审核编辑：汤梓红

声明：本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人，不代表电子发烧友网立场。文章及其配图仅供工程师学习之用，如有内容侵权或者其他违规问题，请联系本站处理。举报投诉

C语言

C语言

+关注

关注
180

文章
7530

浏览量
128484
二叉树

二叉树

+关注

关注
0

文章
74

浏览量
12238

原文标题：平衡二叉树 C语言代码实现

文章出处：【微信号：技术让梦想更伟大，微信公众号：技术让梦想更伟大】欢迎添加关注！文章转载请注明出处。

二叉树和二叉树的性质(1)#数据结构

数据函数二叉树

未来加油dz

发布于 :2023年09月05日 09:06:44

二叉树和二叉树的性质(2)#数据结构

数据函数二叉树

未来加油dz

发布于 :2023年09月05日 09:08:32

二叉树和二叉树的性质(3)#数据结构

数据函数二叉树

未来加油dz

发布于 :2023年09月05日 09:09:51

平衡二叉树(1)#数据结构

数据函数二叉树

未来加油dz

发布于 :2023年09月05日 09:42:30

平衡二叉树(2)#数据结构

数据函数二叉树

未来加油dz

发布于 :2023年09月05日 09:43:54

平衡二叉树(3)#数据结构

数据函数二叉树

未来加油dz

发布于 :2023年09月05日 09:45:06

计算机二级二叉树的问题

各位大神，本人马上要考计算机二级了，那个二叉树老是弄不明白，比如一个题目，一棵二叉树共有25个节点，其中五个叶子节点，则度为1的节点数为？

发表于 09-04 09:45

二叉树删除算法

二叉树的删除操作主要是寻找替代点来进行替换操作。方法：先右转，再一直左转，直到左连接为空的那个点。然后，摘取出来，完成链接指向操作。public void deletmin(void){ root

发表于 12-30 20:55

二叉查找树（GIF动图讲解）

二叉查找树（Binary Search Tree），也称二叉搜索树，是指一棵空树或者具有下列性质的二叉树

发表于 07-29 15:24

用C语言构建一个二叉树失败

; ,tree.leftnode->data);这三个输出都是乱码，我不知道二叉树的建立过程中问题在哪里，我应该在每个节点都分配了内存，不过结果好像有问题}

发表于 03-24 03:47

什么是“红黑树”看了就知道

今天我们要说的红黑树就是就是一棵非严格均衡的二叉树，均衡二叉树又是在二叉搜索树的基础上增加了自动维持平衡

发表于 10-27 17:00

Java编程求二叉树的镜像两种方法介绍

给出一棵二叉树，求它的镜像，如下图：右边是二叉树是左边二叉树的镜像。仔细分析这两棵树的特点，看看能不能总结出求镜像的步骤。这两棵树的根节点相

发表于 12-16 16:25

MySQL数据库索引的底层是怎么实现的

二叉树，B树，B+树这4种数据结构，以及为啥选用B+树作为mysql数据库的数据结构。首先看下这四种数据结构示例图。哈希表平衡

发表于 07-28 15:30

C语言二叉树代码免费下载

本文档的主要内容详细介绍的是C语言二叉树代码免费下载。

发表于 08-27 08:00 •1次下载

二叉树的代码实现

二叉树的主要操作有遍历，例如有先序遍历、中序遍历、后序遍历。在遍历之前，就是创建一棵二叉树，当然，还需要有删除二叉树的算法。

发表于 01-18 10:41 •906次阅读

搜索历史

使用C语言代码实现平衡二叉树

1. 什么是平衡二叉树

2. 如何判断二叉树最小不平衡子树

3. 二叉树不平衡情况

4. 判断不平衡二叉树哪边高

5. 如何调整平衡二叉树

全部代码

评论

二叉树和二叉树的性质(1)#数据结构

二叉树和二叉树的性质(2)#数据结构

二叉树和二叉树的性质(3)#数据结构

平衡二叉树(1)#数据结构

平衡二叉树(2)#数据结构

平衡二叉树(3)#数据结构

计算机二级二叉树的问题

二叉树删除算法

二叉查找树（GIF动图讲解）

用C语言构建一个二叉树失败

什么是“红黑树”看了就知道

Java编程求二叉树的镜像两种方法介绍

MySQL数据库索引的底层是怎么实现的

C语言二叉树代码免费下载

二叉树的代码实现