一、定義(AVL樹)
平衡二叉樹定義(AVL):
要么它是一顆空樹，或者具有以下性質的二叉排序樹:它的左子樹和右子樹都是平衡二叉樹，且左子樹和右子樹的深度之差的絕對值不超過1.
二、平衡二叉樹相關概念
平衡因子BF(Balance Factor):
將二叉樹上結點的左子樹高度減去右子樹高度的值稱為該結點的平衡因子BF(Balance Factor)。
也就是說，對于平衡二叉樹，BF的取值范圍為[-1,1]，如果發現某個結點的BF值不在此范圍，則需要對樹進行調整。
最小不平衡樹
距離插入結點最近的，且平衡因子的絕對值大于1的結點的根的子樹。
如圖所示，左邊二叉樹的結點45的BF=1，而在插入43結點后，45結點的BF=2。結點45是距離插入結點43最近的BF不在[-1,1]范圍內的結點，因此以結點45為根節點的子樹為最小不平衡樹。
三、平衡二叉樹的平衡調整
定義
typedef enum Status{
success = 0,//成功
fail = 1//失敗
}Status;
//二叉樹結點定義
typedef struct BinaryTreeNode{
int val;//存儲的值
struct BinaryTreeNode *lChild,*rChild;//左右孩子
int height;//深度
}BinaryTreeNode,*BinaryTree;
實現過程就是通過在一棵平衡二叉樹中一次插入結點(按照二叉排序樹的方式)，若出現不平衡，則要根據新插入的結點與最低不平衡結點的位置關系進行相應調整。分為LL型、RR型、LR型和RL型四種類型，各調整方法如下(用A表示最低不平衡結點)。
1.LL型調整
在A的左孩子的左孩子上插入新節點，使得A的BF從1增到2，按照大小關系，結點B應作為新的根節點，其余兩個結點分別作為左右孩子結點才能平衡，A結點就好像是繞結點B順時針旋轉一樣。
具體算法步驟如下:
① 將A的左孩子B提升為新的根節點
② 將原來的根節點A降為B的右孩子
③ 各子樹按照大小關系連接(BL和AR不變，BR調整為A的左子樹)
/// LL型旋轉
/// @param node 原根節點
void ll_rotate(BinaryTree *node){
BinaryTree A = *node;
//取出B結點作為新的根節點
BinaryTree B = A->lChild;
//B的右子樹作為A的左子樹(因為B這邊都是比A小，所以只能為左子樹)
A->lChild = B->rChild;
//B的右子樹為A
B->rChild = A;
A->height = max(height(A->lChild), height(A->rChild)) + 1;
B->height = max(height(B->lChild), height(B->rChild)) + 1;
*node = B;
}
2.RR型調整
在A的右孩子B的右孩子上插入新結點C，使得A的平衡因子BF從-1變為-2，按照大小關系，結點B應作為新的根節點，其余兩個結點分別作為左右孩子結點才能平衡，A結點就好像是繞B逆時針旋轉一樣。
具體算法步驟如下：
① 將A的右孩子B提升為新的根節點
② 將原來的根節點A降為B的左孩子
③ 各子樹按照大小關系(AL和BR不變，將BL調整為A的右子樹)
/// rr型旋轉
/// @param node 原根節點
void rr_rotate(BinaryTree *node){
BinaryTree A = *node;
//取出B結點作為新的根節點
BinaryTree B = A->rChild;
//B的左子樹作為A的右子樹(因為B這邊都是比A大，所以只能為右子樹)
A->rChild = B->lChild;
//A作為B的左子樹
B->lChild = A;
A->height = max(height(A->lChild), height(A->rChild)) + 1;
B->height = max(height(B->lChild), height(B->rChild)) + 1;
*node = B;
}
3.LR型調整
在A的左孩子B的右孩子上插入新節點C，使得A的BF從1增大為2，按照大小關系，結點C應該作為新的根節點，其余兩個結點分別作為左右孩子結點才能平衡。
算法步驟如下:
① 將B的右孩子C提升為新的根節點
② 將原來的根節點A降為C的右孩子，B降為C的左孩子
③ 各子樹按照大小關系連接(BL和AR不變，CL和CR分別調整為B的右子樹和A的左子樹)
/// lr型旋轉
/// @param node 原根節點
void lr_rotate(BinaryTree *node){
//先對B進行rr轉換，接著再來一次ll轉換
rr_rotate(&((*node)->lChild));
ll_rotate(node);
}
4.RL型調整
在A的右孩子B的左子樹上插入新節點C，此時A的BF由-1變為-2，按照大小關系，結點C應作為新的根節點，其余兩個結點分別作為左右孩子結點才能平衡。
算法步驟如下:
① 將B的左孩子C提升為新的根節點
② 將原來的根節點A降為C的左孩子，B降為C的右孩子
③ 各子樹按大小關系連接(AL和BR不變，CL和CR分別調整為A的左子樹和B的右子樹)
/// rl型轉換
/// @param node 原根節點
void rl_rotate(BinaryTree *node){
//先對B進行ll型轉換，接著再來一次rr型轉換
ll_rotate(&((*node)->rChild));
rr_rotate(node);
}
四、插入代碼實現
BalanceBinaryTree.h中
#ifndef BalanceBinaryTree_h
#define BalanceBinaryTree_h
#include <stdio.h>
#include <stdlib.h>
typedef enum Status{
success = 0,//成功
fail = 1//失敗
}Status;
//二叉樹結點定義
typedef struct BinaryTreeNode{
int val;//存儲的值
struct BinaryTreeNode *lChild,*rChild;//左右孩子
int height;//深度
}BinaryTreeNode,*BinaryTree;
Status insertVAL(BinaryTree *T,int key);
void preOrder(BinaryTree T);
#endif
BalanceBinaryTree.c中
#include "BalanceBinaryTree.h"
/// 返回高度
/// @param node 樹結點
int height(BinaryTree node){
if (node == NULL) {
return 0;
}
return node->height;
}
int max(int x, int y){
return (x > y) ? x : y;
}
/// 生成一個新的結點
/// @param key 結點的值
BinaryTree newNode(int key){
BinaryTree node = (BinaryTree)malloc(sizeof(BinaryTreeNode));
node->val = key;
node->lChild = node->rChild = 0;
node->height = 1;
return node;
}
/// LL型旋轉
/// @param node 原根節點
void ll_rotate(BinaryTree *node){
BinaryTree A = *node;
//取出B結點作為新的根節點
BinaryTree B = A->lChild;
//B的右子樹作為A的左子樹(因為B這邊都是比A小，所以只能為左子樹)
A->lChild = B->rChild;
//B的右子樹為A
B->rChild = A;
A->height = max(height(A->lChild), height(A->rChild)) + 1;
B->height = max(height(B->lChild), height(B->rChild)) + 1;
*node = B;
}
/// rr型旋轉
/// @param node 原根節點
void rr_rotate(BinaryTree *node){
BinaryTree A = *node;
//取出B結點作為新的根節點
BinaryTree B = A->rChild;
//B的左子樹作為A的右子樹(因為B這邊都是比A大，所以只能為右子樹)
A->rChild = B->lChild;
//A作為B的左子樹
B->lChild = A;
A->height = max(height(A->lChild), height(A->rChild)) + 1;
B->height = max(height(B->lChild), height(B->rChild)) + 1;
*node = B;
}
/// lr型旋轉
/// @param node 原根節點
void lr_rotate(BinaryTree *node){
//先對B進行rr轉換，接著再來一次ll轉換
rr_rotate(&((*node)->lChild));
ll_rotate(node);
}
/// rl型轉換
/// @param node 原根節點
void rl_rotate(BinaryTree *node){
//先對B進行ll型轉換，接著再來一次rr型轉換
ll_rotate(&((*node)->rChild));
rr_rotate(node);
}
/// 獲取結點的平衡因子
/// @param node 結點
int getBF(BinaryTree node){
if (!node) {
return 0;
}
return height(node->lChild) - height(node->rChild);
}
Status insertVAL(BinaryTree *T,int key){
if (!*T) {
//空樹，直接新建一個結點
*T = newNode(key);
return success;
}
if (key < (*T)->val) {
//如果比結點的值小，從左子樹去找地方插入
insertVAL(&((*T)->lChild), key);
} else if (key > (*T)->val) {
//如果比結點的值大，從右子樹去找地方插入
insertVAL(&((*T)->rChild), key);
} else {
//相等因為沒有插入新結點，所以直接返回
// return fail;
}
(*T)->height = 1 + max(height((*T)->lChild), height((*T)->rChild));
int bf = getBF(*T);
printf("%d,key:%d bf:%d\n",(*T)->val,key,bf);
if (bf > 1 && key < (*T)->lChild->val) {
//ll型
ll_rotate(T);
} else if (bf < -1 && key > (*T)->rChild->val){
//rr型
rr_rotate(T);
} else if (bf > 1 && key > (*T)->lChild->val){
//lr型
lr_rotate(T);
} else if (bf < -1 && key < (*T)->rChild->val){
//rl型
rl_rotate(T);
}
return success;
}
void preOrder(BinaryTree T){
if (!T) {
return;
}
printf("%d ",T->val);
preOrder(T->lChild);
preOrder(T->rChild);
}
我們進行測試,在main.c中：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "BalanceBinaryTree.h"
int main(int argc, const char * argv[]) {
BinaryTree T = NULL;
int arr[] = {2,10,3,5,6,1,7,9};
for (int i = 0; i < 8; i++) {
insertVAL(&T, arr[i]);
}
//前序遍歷
preOrder(T);
return 0;
}
/*
打印結果:
2,key:10 bf:-1
10,key:3 bf:1
2,key:3 bf:-2
10,key:5 bf:1
3,key:5 bf:-1
5,key:6 bf:-1
10,key:6 bf:2
3,key:6 bf:-1
2,key:1 bf:1
3,key:1 bf:0
10,key:7 bf:1
6,key:7 bf:-1
3,key:7 bf:-1
7,key:9 bf:-1
10,key:9 bf:2
6,key:9 bf:-1
3,key:9 bf:-1
3 2 1 6 5 9 7 10 Program ended with exit code: 0
*/
參考自:
平衡二叉樹
