二叉树

二叉树

「二叉树 binary tree」是一种非线性数据结构，代表着祖先与后代之间的派生关系，体现着“一分为二”的
分治逻辑。与链表类似，二叉树的基本单元是节点，每个节点包含：值、左子节点引用、右子节点引用。

/* 二叉树节点结构体 */
typedef struct TreeNode {
int val; // 节点值
int height; // 节点高度
struct TreeNode *left; // 左子节点指针
struct TreeNode *right; // 右子节点指针
} TreeNode;
/* 构造函数 */
TreeNode *newTreeNode(int val) {
TreeNode *node;
node = (TreeNode *)malloc(sizeof(TreeNode));
node->val = val;
node->height = 0;
node->left = NULL;
node->right = NULL;
return node;
}

每个节点都有两个引用（指针），分别指向「左子节点 left‑child node」和「右子节点 right‑child node」，
该节点被称为这两个子节点的「父节点 parent node」。当给定一个二叉树的节点时，我们将该节点的左子
节点及其以下节点形成的树称为该节点的「左子树 left subtree」，同理可得「右子树 right subtree」。
在二叉树中，除叶节点外，其他所有节点都包含子节点和非空子树。如图 7‑1 所示，如果将“节点 2”视为父
节点，则其左子节点和右子节点分别是“节点 4”和“节点 5”，左子树是“节点 4 及其以下节点形成的树”，
右子树是“节点 5 及其以下节点形成的树”

7.1.1 二叉树常见术语
二叉树的常用术语如图 7‑2 所示。

‧「根节点 root node」：位于二叉树顶层的节点，没有父节点。

‧「叶节点 leaf node」：没有子节点的节点，其两个指针均指向 None 。

‧「边 edge」：连接两个节点的线段，即节点引用（指针）。

‧ 节点所在的「层 level」：从顶至底递增，根节点所在层为 1 。

‧ 节点的「度 degree」：节点的子节点的数量。在二叉树中，度的取值范围是 0、1、2 。

‧ 二叉树的「高度 height」：从根节点到最远叶节点所经过的边的数量。

‧ 节点的「深度 depth」：从根节点到该节点所经过的边的数量。

‧ 节点的「高度 height」：从距离该节点最远的叶节点到该节点所经过的边的数量。

请注意，我们通常将“高度”和“深度”定义为“走过边的数量”，但有些题目或教材可能会
将其定义为“走过节点的数量”。在这种情况下，高度和深度都需要加 1 。

7.1.2 二叉树基本操作

1. 初始化二叉树
   与链表类似，首先初始化节点，然后构建引用（指针）。

   // === File: binary_tree.c ===
   /* 初始化二叉树 */
   // 初始化节点
   TreeNode *n1 = newTreeNode(1);
   TreeNode *n2 = newTreeNode(2);
   TreeNode *n3 = newTreeNode(3);
   TreeNode *n4 = newTreeNode(4);
   TreeNode *n5 = newTreeNode(5);
   // 构建引用指向（即指针）
   n1->left = n2;
   n1->right = n3;
   n2->left = n4;
   n2->right = n5;

2. 插入与删除节点
   与链表类似，在二叉树中插入与删除节点可以通过修改指针来实现。图 7‑3 给出了一个示例。

// === File: binary_tree.c ===
/* 插入与删除节点 */
TreeNode *P = newTreeNode(0);
// 在 n1 -> n2 中间插入节点 P
n1->left = P;
P->left = n2;
// 删除节点 P
n1->left = n2;

需要注意的是，插入节点可能会改变二叉树的原有逻辑结构，而删除节点通常意味着删除该
节点及其所有子树。因此，在二叉树中，插入与删除操作通常是由一套操作配合完成的，以实
现有实际意义的操作。

7.1.3 常见二叉树类型

1. 完美二叉树
   「完美二叉树 perfect binary tree」所有层的节点都被完全填满。在完美二叉树中，叶节点的度为 0 ，其余所
   有节点的度都为 2 ；若树高度为 ℎ ，则节点总数为 2
   ℎ+1 − 1 ，呈现标准的指数级关系，反映了自然界中常
   见的细胞分裂现象。

请注意，在中文社区中，完美二叉树常被称为「满二叉树」

2. 完全二叉树
   如图 7‑5 所示，「完全二叉树 complete binary tree」只有最底层的节点未被填满，且最底层节点尽量靠左填充。

3. 完满二叉树
   如图 7‑6 所示，「完满二叉树 full binary tree」除了叶节点之外，其余所有节点都有两个子节点。
   

4. 平衡二叉树
   如图 7‑7 所示，「平衡二叉树 balanced binary tree」中任意节点的左子树和右子树的高度之差的绝对值不超过 1 。

7.1.4 二叉树的退化
图 7‑8 展示了二叉树的理想与退化状态。当二叉树的每层节点都被填满时，达到“完美二叉树”；而当所有节
点都偏向一侧时，二叉树退化为“链表”。

‧ 完美二叉树是理想情况，可以充分发挥二叉树“分治”的优势。
‧ 链表则是另一个极端，各项操作都变为线性操作，时间复杂度退化至 𝑂(𝑛) 。

7.2 二叉树遍历

从物理结构的角度来看，树是一种基于链表的数据结构，因此其遍历方式是通过指针逐个访问节点。然而，
树是一种非线性数据结构，这使得遍历树比遍历链表更加复杂，需要借助搜索算法来实现。

二叉树常见的遍历方式包括层序遍历、前序遍历、中序遍历和后序遍历等。

7.2.1 层序遍历

如图 7‑9 所示，「层序遍历 level‑order traversal」从顶部到底部逐层遍历二叉树，并在每一层按照从左到右
的顺序访问节点。

层序遍历本质上属于「广度优先遍历 breadth‑first traversal」，它体现了一种“一圈一圈向外扩展”的逐层
遍历方式。

1. 代码实现

广度优先遍历通常借助“队列”来实现。队列遵循“先进先出”的规则，而广度优先遍历则遵循“逐层推进”
的规则，两者背后的思想是一致的。

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

#define MAX_SIZE 100

struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
};

int *levelOrder(struct TreeNode *root, int *size) {
int front, rear;
int index, *arr;
struct TreeNode *node;
struct TreeNode **queue;

// 创建一个辅助队列
queue = (struct TreeNode **)malloc(sizeof(struct TreeNode *) * MAX_SIZE);
front = 0, rear = 0;
queue[rear++] = root;

// 创建一个辅助数组
arr = (int *)malloc(sizeof(int) * MAX_SIZE);
index = 0;

while (front < rear) {
// 出队
node = queue[front++];

// 保存节点值
arr[index++] = node->val;

// 将左子节点入队
if (node->left != NULL) {
queue[rear++] = node->left;
}

// 将右子节点入队
if (node->right != NULL) {
queue[rear++] = node->right;
}
}

// 更新数组长度值
*size = index;

// 重新分配辅助数组的内存空间为实际使用大小，并释放辅助队列的内存空间
arr = realloc(arr, sizeof(int) * (*size));
free(queue);

return arr;
}

int main() {
// 创建一个二叉树
struct TreeNode *root = (struct TreeNode *)malloc(sizeof(struct TreeNode));
root->val = 1;
root->left = (struct TreeNode *)malloc(sizeof(struct TreeNode));
root->left->val = 2;
root->left->left = root->left->right = NULL;
root->right = (struct TreeNode *)malloc(sizeof(struct TreeNode));
root->right->val = 3;
root->right->left = root->right->right = NULL;

int size;
int *result = levelOrder(root, &size);

printf("Level order traversal: ");
for (int i = 0; i < size; i++) {
printf("%d ", result[i]);
}

// 释放动态分配的内存空间
free(root->left);
free(root->right);
free(root);
free(result);

return 0;
}

2. 复杂度分析

‧ 时间复杂度 𝑂(𝑛) ：所有节点被访问一次，使用 𝑂(𝑛) 时间，其中 𝑛 为节点数量。

‧ 空间复杂度 𝑂(𝑛) ：在最差情况下，即满二叉树时，遍历到最底层之前，队列中最多同时存在 (𝑛+1)/2
个节点，占用 𝑂(𝑛) 空间。

7.2.2 前序、中序、后序遍历

相应地，前序、中序和后序遍历都属于「深度优先遍历 depth‑first traversal」，它体现了一种“先走到尽头，
再回溯继续”的遍历方式。

图 7‑10 展示了对二叉树进行深度优先遍历的工作原理。深度优先遍历就像是绕着整个二叉树的外围“走”一
圈，在每个节点都会遇到三个位置，分别对应前序遍历、中序遍历和后序遍历。

1. 代码实现

深度优先搜索通常基于递归实现：

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

struct TreeNode {
int val;
struct TreeNode* left;
struct TreeNode* right;
};

#define MAX_SIZE 100

/* 前序遍历 */
void preOrder(struct TreeNode* root, int* arr, int* size) {
if (root == NULL)
return;

// 访问优先级：根节点 -> 左子树 -> 右子树
arr[(*size)++] = root->val;

preOrder(root->left, arr, size);
preOrder(root->right, arr, size);
}

/* 中序遍历 */
void inOrder(struct TreeNode* root, int* arr, int* size) {
if (root == NULL)
return;

// 访问优先级：左子树 -> 根节点 -> 右子树
inOrder(root->left, arr, size);
arr[(*size)++] = root->val;
inOrder(root->right, arr, size);
}

/* 后序遍历 */
void postOrder(struct TreeNode* root, int* arr, int* size) {
if (root == NULL)
return;

// 访问优先级：左子树 -> 右子树 -> 根节点
postOrder(root->left, arr, size);
postOrder(root->right, arr, size);
arr[(*size)++] = root->val;
}

int main() {
// 创建一个二叉树
struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
root->val = 1;
root->left = (struct TreeNode*)malloc(sizeof(struct TreeNode));
root->left->val = 2;
root->left->left = root->left->right = NULL;
root->right = (struct TreeNode*)malloc(sizeof(struct TreeNode));
root->right->val = 3;
root->right->left = root->right->right = NULL;

int size = 0;
int arr[MAX_SIZE];

// 前序遍历
printf("Preorder traversal: ");
preOrder(root, arr, &size);
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}

size = 0; // 重置 size

// 中序遍历
printf("\nInorder traversal: ");
inOrder(root, arr, &size);
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}

size = 0; // 重置 size

// 后序遍历
printf("\nPostorder traversal: ");
postOrder(root, arr, &size);
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}

// 释放动态分配的内存空间
free(root->left);
free(root->right);
free(root);

return 0;
}

深度优先搜索也可以基于迭代实现，有兴趣的同学可以自行研究。

图 7‑11 展示了前序遍历二叉树的递归过程，其可分为“递”和“归”两个逆向的部分。

1.“递”表示开启新方法，程序在此过程中访问下一个节点。

2.“归”表示函数返回，代表当前节点已经访问完毕。

2. 复杂度分析

‧ 时间复杂度 𝑂(𝑛) ：所有节点被访问一次，使用 𝑂(𝑛) 时间。

‧ 空间复杂度 𝑂(𝑛) ：在最差情况下，即树退化为链表时，递归深度达到 𝑛 ，系统占用 𝑂(𝑛) 栈帧空间。

7.3 二叉树数组表示

在链表表示下，二叉树的存储单元为节点 TreeNode ，节点之间通过指针相连接。在上节中，我们学习了在链
表表示下的二叉树的各项基本操作。

那么，我们能否用数组来表示二叉树呢？答案是肯定的。

7.3.1 表示完美二叉树

先分析一个简单案例。给定一个完美二叉树，我们将所有节点按照层序遍历的顺序存储在一个数组中，则每
个节点都对应唯一的数组索引。

根据层序遍历的特性，我们可以推导出父节点索引与子节点索引之间的“映射公式”：若节点的索引为 𝑖 ，则
该节点的左子节点索引为 2𝑖 + 1 ，右子节点索引为 2𝑖 + 2 。图 7‑12 展示了各个节点索引之间的映射关系。

映射公式的角色相当于链表中的指针。给定数组中的任意一个节点，我们都可以通过映射公式来访问它的左
（右）子节点。

7.3.2 表示任意二叉树

完美二叉树是一个特例，在二叉树的中间层通常存在许多 None 。由于层序遍历序列并不包含这些 None ，
因此我们无法仅凭该序列来推测 None 的数量和分布位置。这意味着存在多种二叉树结构都符合该层序遍历
序列。

如图 7‑13 所示，给定一个非完美二叉树，上述的数组表示方法已经失效。

为了解决此问题，我们可以考虑在层序遍历序列中显式地写出所有 None 。如图 7‑14 所示，这样处理后，层
序遍历序列就可以唯一表示二叉树了。

/* 二叉树的数组表示 */
// 使用 int 最大值标记空位，因此要求节点值不能为 INT_MAX
int tree[] = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};

值得说明的是，完全二叉树非常适合使用数组来表示。回顾完全二叉树的定义，None 只出现在最底层且靠
右的位置，因此所有 None 一定出现在层序遍历序列的末尾。

这意味着使用数组表示完全二叉树时，可以省略存储所有 None ，非常方便。图 7‑15 给出了一个例子。

以下代码实现了一个基于数组表示的二叉树，包括以下几种操作。

‧ 给定某节点，获取它的值、左（右）子节点、父节点。

‧ 获取前序遍历、中序遍历、后序遍历、层序遍历序列。

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

int left(int i) {
return 2 * i + 1;
}

int right(int i) {
return 2 * i + 2;
}

/* 数组表示下的二叉树结构体 */
typedef struct {
int* tree; // 二叉树的数组
int size; // 数组的大小
} ArrayBinaryTree;

/* 构造函数 */
ArrayBinaryTree* newArrayBinaryTree(int* arr, int arrSize) {
ArrayBinaryTree* abt = (ArrayBinaryTree*)malloc(sizeof(ArrayBinaryTree));
abt->tree = malloc(sizeof(int) * arrSize);
memcpy(abt->tree, arr, sizeof(int) * arrSize);
abt->size = arrSize;
return abt;
}

/* 析构函数 */
void delArrayBinaryTree(ArrayBinaryTree* abt) {
free(abt->tree);
free(abt);
}

/* 节点数量 */
int size(ArrayBinaryTree* abt) {
return abt->size;
}

/* 获取索引为 i 节点的值 */
int val(ArrayBinaryTree* abt, int i) {
// 若索引越界，则返回 INT_MAX ，代表空位
if (i < 0 || i >= size(abt))
return INT_MAX;
return abt->tree[i];
}

/* 层序遍历 */
int* levelOrder(ArrayBinaryTree* abt, int* returnSize) {
int* res = (int*)malloc(sizeof(int) * size(abt));
int index = 0;
// 直接遍历数组
for (int i = 0; i < size(abt); i++) {
if (val(abt, i) != INT_MAX)
res[index++] = val(abt, i);
}
*returnSize = index;
return res;
}

/* 深度优先遍历 */
void dfs(ArrayBinaryTree* abt, int i, char* order, int* res, int* index) {
// 若为空位，则返回
if (val(abt, i) == INT_MAX)
return;
// 前序遍历
if (strcmp(order, "pre") == 0)
res[(*index)++] = val(abt, i);
dfs(abt, left(i), order, res, index);
// 中序遍历
if (strcmp(order, "in") == 0)
res[(*index)++] = val(abt, i);
dfs(abt, right(i), order, res, index);
// 后序遍历
if (strcmp(order, "post") == 0)
res[(*index)++] = val(abt, i);
}

/* 前序遍历 */
int* preOrder(ArrayBinaryTree* abt, int* returnSize) {
int* res = (int*)malloc(sizeof(int) * size(abt));
int index = 0;

dfs(abt, 0, "pre", res, &index);
*returnSize = index;
return res;
}

/* 中序遍历 */
int* inOrder(ArrayBinaryTree* abt, int* returnSize) {
int* res = (int*)malloc(sizeof(int) * size(abt));
int index = 0;
dfs(abt, 0, "in", res, &index);
*returnSize = index;
return res;
}

/* 后序遍历 */
int* postOrder(ArrayBinaryTree* abt, int* returnSize) {
int* res = (int*)malloc(sizeof(int) * size(abt));
int index = 0;
dfs(abt, 0, "post", res, &index);
*returnSize = index;
return res;
}

int main() {
int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
int arrSize = sizeof(arr) / sizeof(arr[0]);

ArrayBinaryTree* abt = newArrayBinaryTree(arr, arrSize);

// 层序遍历
int levelSize;
int* levelRes = levelOrder(abt, &levelSize);
printf("Level order traversal: ");
for (int i = 0; i < levelSize; i++) {
printf("%d ", levelRes[i]);
}
printf("\n");
free(levelRes);

// 前序遍历
int preSize;
int* preRes = preOrder(abt, &preSize);
printf("Preorder traversal: ");
for (int i = 0; i < preSize; i++) {
printf("%d ", preRes[i]);
}
printf("\n");
free(preRes);

// 中序遍历
int inSize;
int* inRes = inOrder(abt, &inSize);
printf("Inorder traversal: ");
for (int i = 0; i < inSize; i++) {
printf("%d ", inRes[i]);
}
printf("\n");
free(inRes);

// 后序遍历
int postSize;
int* postRes = postOrder(abt, &postSize);
printf("Postorder traversal: ");
for (int i = 0; i < postSize; i++) {
printf("%d ", postRes[i]);
}
printf("\n");
free(postRes);

// 释放内存
delArrayBinaryTree(abt);

return 0;
}

7.3.3 优势与局限性

二叉树的数组表示主要有以下优点。
‧ 数组存储在连续的内存空间中，对缓存友好，访问与遍历速度较快。

‧ 不需要存储指针，比较节省空间。

‧ 允许随机访问节点。

然而，数组表示也存在一些局限性。

‧ 数组存储需要连续内存空间，因此不适合存储数据量过大的树。

‧ 增删节点需要通过数组插入与删除操作实现，效率较低。

‧ 当二叉树中存在大量 None 时，数组中包含的节点数据比重较低，空间利用率较低。

7.4 二叉搜索树

如图 7‑16 所示，「二叉搜索树 binary search tree」满足以下条件。

1. 对于根节点，左子树中所有节点的值 < 根节点的值 < 右子树中所有节点的值。

2. 任意节点的左、右子树也是二叉搜索树，即同样满足条件 1. 。

7.4.1 二叉搜索树的操作

我们将二叉搜索树封装为一个类 BinarySearchTree ，并声明一个成员变量 root ，指向树的根节点。

1. 查找节点

给定目标节点值 num ，可以根据二叉搜索树的性质来查找。如图 7‑17 所示，我们声明一个节点 cur ，从二叉
树的根节点 root 出发，循环比较节点值 cur.val 和 num 之间的大小关系。

‧ 若 cur.val < num ，说明目标节点在 cur 的右子树中，因此执行 cur = cur.right 。

‧ 若 cur.val > num ，说明目标节点在 cur 的左子树中，因此执行 cur = cur.left 。

‧ 若 cur.val = num ，说明找到目标节点，跳出循环并返回该节点。

二叉搜索树的查找操作与二分查找算法的工作原理一致，都是每轮排除一半情况。循环次数最多为二叉树的
高度，当二叉树平衡时，使用 𝑂(log 𝑛) 时间。

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

// 结点结构体
typedef struct TreeNode {
int val;
struct TreeNode* left;
struct TreeNode* right;
} TreeNode;

// 二叉搜索树结构体
typedef struct {
TreeNode* root;
} BinarySearchTree;

// 创建二叉搜索树
BinarySearchTree* createBinarySearchTree() {
BinarySearchTree* bst = (BinarySearchTree*)malloc(sizeof(BinarySearchTree));
bst->root = NULL;
return bst;
}

// 销毁二叉搜索树
void destroyBinarySearchTree(BinarySearchTree* bst) {
// 释放二叉搜索树的内存
// ...
free(bst);
}


// 插入新节点
void insertNode(BinarySearchTree* bst, int num) {
TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));
newNode->val = num;
newNode->left = NULL;
newNode->right = NULL;

// 如果树为空，新节点作为根节点
if (bst->root == NULL) {
bst->root = newNode;
return;
}

TreeNode* cur = bst->root;
TreeNode* parent = NULL; // 初始化 parent 变量

while (cur != NULL) {
parent = cur;
if (num < cur->val) {
cur = cur->left;
}
else {
cur = cur->right;
}
}

if (num < parent->val) {
parent->left = newNode;
}
else {
parent->right = newNode;
}
}

// 查找节点
TreeNode* search(BinarySearchTree* bst, int num) {
TreeNode* cur = bst->root;

// 循环查找，越过叶节点后跳出
while (cur != NULL) {
if (cur->val < num) {
// 目标节点在 cur 的右子树中
cur = cur->right;
}
else if (cur->val > num) {
// 目标节点在 cur 的左子树中
cur = cur->left;
}
else {
// 找到目标节点，跳出循环
break;
}
}

// 返回目标节点
return cur;
}

int main() {
// 创建一个二叉搜索树
BinarySearchTree* bst = createBinarySearchTree();

// 插入一些节点
insertNode(bst, 5);
insertNode(bst, 3);
insertNode(bst, 7);
insertNode(bst, 2);
insertNode(bst, 4);
insertNode(bst, 6);
insertNode(bst, 8);

// 查找节点
int targetValue = 4;
TreeNode* result = search(bst, targetValue);

if (result != NULL) {
printf("找到了节点值为 %d 的节点！", targetValue);
}
else {
printf("未找到节点值为 %d 的节点。", targetValue);
}

// 释放内存
destroyBinarySearchTree(bst);

return 0;
}

2. 插入节点

给定一个待插入元素 num ，为了保持二叉搜索树“左子树 < 根节点 < 右子树”的性质，插入操作流程如图
7‑18 所示。

1. 查找插入位置：与查找操作相似，从根节点出发，根据当前节点值和 num 的大小关系循环向下搜索，直
   到越过叶节点（遍历至 None ）时跳出循环。
2. 在该位置插入节点：初始化节点 num ，将该节点置于 None 的位置。

在代码实现中，需要注意以下两点。

‧ 二叉搜索树不允许存在重复节点，否则将违反其定义。因此，若待插入节点在树中已存在，则不执行插
入，直接返回。

‧ 为了实现插入节点，我们需要借助节点 pre 保存上一轮循环的节点。这样在遍历至 None 时，我们可以
获取到其父节点，从而完成节点插入操作。

// 向二叉搜索树插入节点
void insert(BinarySearchTree* bst, int num) {
if (bst->root == NULL) {
bst->root = newTreeNode(num);
return;
}

TreeNode* cur = bst->root, * pre = NULL;
while (cur != NULL) {
if (cur->val == num) {
return; // 已存在相同值的节点，直接返回
}
pre = cur;
if (cur->val < num) {
cur = cur->right;
}
else {
cur = cur->left;
}
}

TreeNode* node = newTreeNode(num);
if (pre->val < num) {
pre->right = node;
}
else {
pre->left = node;
}
}

与查找节点相同，插入节点使用 𝑂(log 𝑛) 时间。

3. 删除节点

先在二叉树中查找到目标节点，再将其从二叉树中删除。

与插入节点类似，我们需要保证在删除操作完成后，二叉搜索树的“左子树 < 根节点 < 右子树”的性质仍然
满足。

因此，我们需要根据目标节点的子节点数量，共分为 0、1 和 2 这三种情况，执行对应的删除节点操作。
如图 7‑19 所示，当待删除节点的度为 0 时，表示该节点是叶节点，可以直接删除。

如图 7‑20 所示，当待删除节点的度为 1 时，将待删除节点替换为其子节点即可。

当待删除节点的度为 2 时，我们无法直接删除它，而需要使用一个节点替换该节点。由于要保持二叉搜索树
“左 < 根 < 右”的性质，因此这个节点可以是右子树的最小节点或左子树的最大节点。

假设我们选择右子树的最小节点（即中序遍历的下一个节点），则删除操作流程如图 7‑21 所示。

1. 找到待删除节点在“中序遍历序列”中的下一个节点，记为 tmp 。
2. 将 tmp 的值覆盖待删除节点的值，并在树中递归删除节点 tmp 。

删除节点操作同样使用 𝑂(log 𝑛) 时间，其中查找待删除节点需要 𝑂(log 𝑛) 时间，获取中序遍历后继节点需要 𝑂(log 𝑛) 时间。

/* 删除节点 */
// 由于引入了 stdio.h ，此处无法使用 remove 关键词
void removeItem(BinarySearchTree *bst, int num) {
// 若树为空，直接提前返回
if (bst->root == NULL)
return;
TreeNode *cur = bst->root, *pre = NULL;
// 循环查找，越过叶节点后跳出
while (cur != NULL) {
// 找到待删除节点，跳出循环
if (cur->val == num)
break;
pre = cur;
if (cur->val < num) {
// 待删除节点在 root 的右子树中
cur = cur->right;
} else {
// 待删除节点在 root 的左子树中
cur = cur->left;
}
}
// 若无待删除节点，则直接返回
if (cur == NULL)
return;
// 判断待删除节点是否存在子节点
if (cur->left == NULL || cur->right == NULL) {
/* 子节点数量 = 0 or 1 */
// 当子节点数量 = 0 / 1 时， child = nullptr / 该子节点
TreeNode *child = cur->left != NULL ? cur->left : cur->right;
// 删除节点 cur
if (pre->left == cur) {
pre->left = child;
} else {
pre->right = child;
}
} else {
/* 子节点数量 = 2 */
// 获取中序遍历中 cur 的下一个节点
TreeNode *tmp = cur->right;
while (tmp->left != NULL) {
tmp = tmp->left;
}
int tmpVal = tmp->val;
// 递归删除节点 tmp
removeItem(bst, tmp->val);
// 用 tmp 覆盖 cur
cur->val = tmpVal;
}
}

4. 中序遍历有序

如图 7‑22 所示，二叉树的中序遍历遵循“左 → 根 → 右”的遍历顺序，而二叉搜索树满足“左子节点 < 根
节点 < 右子节点”的大小关系。

这意味着在二叉搜索树中进行中序遍历时，总是会优先遍历下一个最小节点，从而得出一个重要性质：二叉
搜索树的中序遍历序列是升序的。

利用中序遍历升序的性质，我们在二叉搜索树中获取有序数据仅需 𝑂(𝑛) 时间，无须进行额外的排序操作，
非常高效。

7.4.2 二叉搜索树的效率

给定一组数据，我们考虑使用数组或二叉搜索树存储。观察表 7‑2 ，二叉搜索树的各项操作的时间复杂度都
是对数阶，具有稳定且高效的性能表现。只有在高频添加、低频查找删除的数据适用场景下，数组比二叉搜
索树的效率更高。

无序数组 二叉搜索树

查找元素 𝑂(𝑛) 𝑂(log 𝑛)

插入元素 𝑂(1) 𝑂(log 𝑛)

删除元素 𝑂(𝑛) 𝑂(log 𝑛)

在理想情况下，二叉搜索树是“平衡”的，这样就可以在 log 𝑛 轮循环内查找任意节点。

然而，如果我们在二叉搜索树中不断地插入和删除节点，可能导致二叉树退化为图 7‑23 所示的链表，这时各种操作的时间复杂度也会退化为 𝑂(𝑛) 。

7.4.3 二叉搜索树常见应用
‧ 用作系统中的多级索引，实现高效的查找、插入、删除操作。

‧ 作为某些搜索算法的底层数据结构。

‧ 用于存储数据流，以保持其有序状态。

7.5 AVL 树 *
在二叉搜索树章节中，我们提到了在多次插入和删除操作后，二叉搜索树可能退化为链表。这种情况下，所
有操作的时间复杂度将从 𝑂(log 𝑛) 恶化为 𝑂(𝑛) 。

如图 7‑24 所示，经过两次删除节点操作，这个二叉搜索树便会退化为链表。

再例如，在图 7‑25 的完美二叉树中插入两个节点后，树将严重向左倾斜，查找操作的时间复杂度也随之恶
化。

G. M. Adelson‑Velsky 和 E. M. Landis 在其 1962 年发表的论文“An algorithm for the organization of
information”中提出了「AVL 树」。论文中详细描述了一系列操作，确保在持续添加和删除节点后，AVL 树
不会退化，从而使得各种操作的时间复杂度保持在 𝑂(log 𝑛) 级别。换句话说，在需要频繁进行增删查改操
作的场景中，AVL 树能始终保持高效的数据操作性能，具有很好的应用价值。

7.5.1 AVL 树常见术语

AVL 树既是二叉搜索树也是平衡二叉树，同时满足这两类二叉树的所有性质，因此也被称为「平衡二叉搜索
树 balanced binary search tree」。

1. 节点高度

由于 AVL 树的相关操作需要获取节点高度，因此我们需要为节点类添加 height 变量。

/* AVL 树节点结构体 */
TreeNode struct TreeNode {
int val;
int height;
struct TreeNode *left;
struct TreeNode *right;
} TreeNode;
/* 构造函数 */
TreeNode *newTreeNode(int val) {
TreeNode *node;
node = (TreeNode *)malloc(sizeof(TreeNode));
node->val = val;
node->height = 0;
node->left = NULL;
node->right = NULL;
return node;
}

“节点高度”是指从该节点到其最远叶节点的距离，即所经过的“边”的数量。需要特别注意的是，叶节点的
高度为 0 ，而空节点的高度为 ‑1 。我们将创建两个工具函数，分别用于获取和更新节点的高度。

// === File: avl_tree.c ===
/* 获取节点高度 */
int height(TreeNode *node) {
// 空节点高度为 -1 ，叶节点高度为 0
if (node != NULL) {
return node->height;
}
return -1;
}
/* 更新节点高度 */
void updateHeight(TreeNode *node) {
int lh = height(node->left);
int rh = height(node->right);
// 节点高度等于最高子树高度 + 1
if (lh > rh) {
node->height = lh + 1;
} else {
node->height = rh + 1;
}
}

2. 节点平衡因子

节点的「平衡因子 balance factor」定义为节点左子树的高度减去右子树的高度，同时规定空节点的平衡因
子为 0 。我们同样将获取节点平衡因子的功能封装成函数，方便后续使用。

/* 获取平衡因子 */
int balanceFactor(TreeNode *node) {
// 空节点平衡因子为 0
if (node == NULL) {
return 0;
}
// 节点平衡因子 = 左子树高度 - 右子树高度
return height(node->left) - height(node->right);
}

设平衡因子为 𝑓 ，则一棵 AVL 树的任意节点的平衡因子皆满足 −1 ≤ 𝑓 ≤ 1 。

7.5.2 AVL 树旋转

AVL 树的特点在于“旋转”操作，它能够在不影响二叉树的中序遍历序列的前提下，使失衡节点重新恢复平
衡。换句话说，旋转操作既能保持“二叉搜索树”的性质，也能使树重新变为“平衡二叉树”。

我们将平衡因子绝对值 > 1 的节点称为“失衡节点”。根据节点失衡情况的不同，旋转操作分为四种：右旋、左旋、先右旋后左旋、先左旋后右旋。下面我们将详细介绍这些旋转操作。

1. 右旋

如图 7‑26 所示，节点下方为平衡因子。从底至顶看，二叉树中首个失衡节点是“节点 3”。我们关注以该失衡节点为根节点的子树，将该节点记为 node ，其左子节点记为 child ，执行“右旋”操作。完成右旋后，子树已经恢复平衡，并且仍然保持二叉搜索树的特性。

如图 7‑27 所示，当节点 child 有右子节点（记为 grandChild ）时，需要在右旋中添加一步：将 grandChild作为 node 的左子节点。

“向右旋转”是一种形象化的说法，实际上需要通过修改节点指针来实现，代码如下所示。

/* 右旋操作 */
TreeNode *rightRotate(TreeNode *node) {
TreeNode *child, *grandChild;
child = node->left;
grandChild = child->right;
// 以 child 为原点，将 node 向右旋转
child->right = node;
node->left = grandChild;
// 更新节点高度
updateHeight(node);
updateHeight(child);
// 返回旋转后子树的根节点
return child;
}

2. 左旋

相应的，如果考虑上述失衡二叉树的“镜像”，则需要执行图 7‑28 所示的“左旋”操作。

同理，如图 7‑29 所示，当节点 child 有左子节点（记为 grandChild ）时，需要在左旋中添加一步：将grandChild 作为 node 的右子节点。

可以观察到，右旋和左旋操作在逻辑上是镜像对称的，它们分别解决的两种失衡情况也是对称的。基于对称性，我们只需将右旋的实现代码中的所有的 left 替换为 right ，将所有的 right 替换为 left ，即可得到左旋的实现代码。

/* 左旋操作 */
TreeNode *leftRotate(TreeNode *node) {
TreeNode *child, *grandChild;
child = node->right;
grandChild = child->left;
// 以 child 为原点，将 node 向左旋转
child->left = node;
node->right = grandChild;
// 更新节点高度
updateHeight(node);
updateHeight(child);
// 返回旋转后子树的根节点
return child;
}

3. 先左旋后右旋

对于图 7‑30 中的失衡节点 3 ，仅使用左旋或右旋都无法使子树恢复平衡。此时需要先对 child 执行“左旋”，再对 node 执行“右旋”。

4. 先右旋后左旋

如图 7‑31 所示，对于上述失衡二叉树的镜像情况，需要先对 child 执行“右旋”，然后对 node 执行“左旋”。

5. 旋转的选择
   图 7‑32 展示的四种失衡情况与上述案例逐个对应，分别需要采用右旋、左旋、先右后左、先左后右的旋转操作

如下表所示，我们通过判断失衡节点的平衡因子以及较高一侧子节点的平衡因子的正负号，来确定失衡节点属于图 7‑32 中的哪种情况。

为了便于使用，我们将旋转操作封装成一个函数。有了这个函数，我们就能对各种失衡情况进行旋转，使失衡节点重新恢复平衡。

// === File: avl_tree.c ===
/* 执行旋转操作，使该子树重新恢复平衡 */
TreeNode *rotate(TreeNode *node) {
// 获取节点 node 的平衡因子
int bf = balanceFactor(node);
// 左偏树
if (bf > 1) {
if (balanceFactor(node->left) >= 0) {
// 右旋
return rightRotate(node);
} else {
// 先左旋后右旋
node->left = leftRotate(node->left);
return rightRotate(node);
}
}
// 右偏树
if (bf < -1) {
if (balanceFactor(node->right) <= 0) {
// 左旋
return leftRotate(node);
} else {
// 先右旋后左旋
node->right = rightRotate(node->right);
return leftRotate(node);
}
}
// 平衡树，无须旋转，直接返回
return node;
}

7.5.3 AVL 树常用操作

1. 插入节点

AVL 树的节点插入操作与二叉搜索树在主体上类似。唯一的区别在于，在 AVL 树中插入节点后，从该节点到根节点的路径上可能会出现一系列失衡节点。因此，我们需要从这个节点开始，自底向上执行旋转操作，使所有失衡节点恢复平衡。

// === File: avl_tree.c ===
/* 插入节点 */
void insert(AVLTree *tree, int val) {
tree->root = insertHelper(tree->root, val);
}
/* 递归插入节点（辅助函数） */
TreeNode *insertHelper(TreeNode *node, int val) {
if (node == NULL) {
return newTreeNode(val);
}
/* 1. 查找插入位置，并插入节点 */
if (val < node->val) {
node->left = insertHelper(node->left, val);

} else if (val > node->val) {
node->right = insertHelper(node->right, val);
} else {
// 重复节点不插入，直接返回
return node;
}
// 更新节点高度
updateHeight(node);
/* 2. 执行旋转操作，使该子树重新恢复平衡 */
node = rotate(node);
// 返回子树的根节点
return node;
}

2. 删除节点

类似地，在二叉搜索树的删除节点方法的基础上，需要从底至顶地执行旋转操作，使所有失衡节点恢复平
衡。

// === File: avl_tree.c ===
/* 删除节点 */
// 由于引入了 stdio.h ，此处无法使用 remove 关键词
void removeItem(AVLTree *tree, int val) {
TreeNode *root = removeHelper(tree->root, val);
}
/* 递归删除节点（辅助函数） */
TreeNode *removeHelper(TreeNode *node, int val) {
TreeNode *child, *grandChild;
if (node == NULL) {
return NULL;
}
/* 1. 查找节点，并删除之 */
if (val < node->val) {
node->left = removeHelper(node->left, val);
} else if (val > node->val) {
node->right = removeHelper(node->right, val);
} else {
if (node->left == NULL || node->right == NULL) {
child = node->left;
if (node->right != NULL) {
child = node->right;
}
// 子节点数量 = 0 ，直接删除 node 并返回
if (child == NULL) {

return NULL;
} else {
// 子节点数量 = 1 ，直接删除 node
node = child;
}
} else {
// 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
TreeNode *temp = node->right;
while (temp->left != NULL) {
temp = temp->left;
}
int tempVal = temp->val;
node->right = removeHelper(node->right, temp->val);
node->val = tempVal;
}
}
// 更新节点高度
updateHeight(node);
/* 2. 执行旋转操作，使该子树重新恢复平衡 */
node = rotate(node);
// 返回子树的根节点
return node;
}

3. 查找节点

AVL 树的节点查找操作与二叉搜索树一致，在此不再赘述。

7.5.4 AVL 树典型应用

‧ 组织和存储大型数据，适用于高频查找、低频增删的场景。

‧ 用于构建数据库中的索引系统。

‧ 红黑树在许多应用中比 AVL 树更受欢迎。这是因为红黑树的平衡条件相对宽松，在红黑树中插入与删
除节点所需的旋转操作相对较少，其节点增删操作的平均效率更高。

7.6 小结

1. 重点回顾

‧ 二叉树是一种非线性数据结构，体现“一分为二”的分治逻辑。每个二叉树节点包含一个值以及两个指
针，分别指向其左子节点和右子节点。

‧ 对于二叉树中的某个节点，其左（右）子节点及其以下形成的树被称为该节点的左（右）子树。

‧ 二叉树的相关术语包括根节点、叶节点、层、度、边、高度和深度等。

‧ 二叉树的初始化、节点插入和节点删除操作与链表操作方法类似。

‧ 常见的二叉树类型有完美二叉树、完全二叉树、完满二叉树和平衡二叉树。完美二叉树是最理想的状态，而链表是退化后的最差状态。

‧ 二叉树可以用数组表示，方法是将节点值和空位按层序遍历顺序排列，并根据父节点与子节点之间的
索引映射关系来实现指针。

‧ 二叉树的层序遍历是一种广度优先搜索方法，它体现了“一圈一圈向外”的分层遍历方式，通常通过队
列来实现。

‧ 前序、中序、后序遍历皆属于深度优先搜索，它们体现了“走到尽头，再回头继续”的回溯遍历方式，
通常使用递归来实现。

‧ 二叉搜索树是一种高效的元素查找数据结构，其查找、插入和删除操作的时间复杂度均为 𝑂(log 𝑛) 。
当二叉搜索树退化为链表时，各项时间复杂度会劣化至 𝑂(𝑛) 。

‧ AVL 树，也称为平衡二叉搜索树，它通过旋转操作，确保在不断插入和删除节点后，树仍然保持平衡。

‧ AVL 树的旋转操作包括右旋、左旋、先右旋再左旋、先左旋再右旋。在插入或删除节点后，AVL 树会
从底向顶执行旋转操作，使树重新恢复平衡。