AVL树完整实现与深度解析

AVL树原理与C++完整实现（标准Markdown语法，可直接复制）

### 文章目录

[AVL树原理与C++完整实现（标准Markdown语法，可直接复制）](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[目录](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[@[toc]](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[一、AVL树核心原理](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[1.1 什么是AVL树](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[1.2 平衡因子（Balance Factor）](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[1.3 四种失衡类型与旋转方案](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[二、AVL树节点结构设计](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[三、AVL树主体类定义](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[四、右单旋（RotateR）](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[4.1 适用场景](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[4.2 实现代码](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[五、左单旋（RotateL）](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[5.1 适用场景](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[5.2 实现代码](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[六、左右双旋（RotateLR）](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[6.1 适用场景](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[6.2 实现代码](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[七、右左双旋（RotateRL）](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[7.1 适用场景](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[7.2 实现代码](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[八、AVL树插入（Insert）](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[8.1 核心逻辑](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[8.2 完整实现代码](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[九、辅助功能实现](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[9.1 树高度计算](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[9.2 平衡验证](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[9.3 中序遍历](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[十、测试主函数](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[十一、代码运行说明](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[十二、AVL树核心总结](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[12.1 旋转规则](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[12.2 插入回溯规则](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[12.3 关键细节](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)
[十三、常见面试考点](#文章目录 AVL树原理与C++完整实现（标准Markdown语法，可直接复制）目录 @[toc] 一、AVL树核心原理 1.1 什么是AVL树 1.2 平衡因子（Balance Factor） 1.3 四种失衡类型与旋转方案二、AVL树节点结构设计三、AVL树主体类定义四、右单旋（RotateR） 4.1 适用场景 4.2 实现代码五、左单旋（RotateL） 5.1 适用场景 5.2 实现代码六、左右双旋（RotateLR） 6.1 适用场景 6.2 实现代码七、右左双旋（RotateRL） 7.1 适用场景 7.2 实现代码八、AVL树插入（Insert） 8.1 核心逻辑 8.2 完整实现代码九、辅助功能实现 9.1 树高度计算 9.2 平衡验证 9.3 中序遍历十、测试主函数十一、代码运行说明十二、AVL树核心总结 12.1 旋转规则 12.2 插入回溯规则 12.3 关键细节十三、常见面试考点)

一、AVL树核心原理

1.1 什么是AVL树

AVL树是自平衡二叉搜索树，是最早被发明的平衡二叉树结构。

它的核心特点：

继承二叉搜索树BST的全部性质
任意节点的左右子树高度差绝对值 ≤ 1
插入/删除后自动通过旋转恢复平衡
查找、插入、删除时间复杂度稳定为 O(logN)

解决了普通二叉搜索树有序插入退化为链表的致命缺陷。

1.2 平衡因子（Balance Factor）

平衡因子是AVL树判断是否失衡的唯一依据：

复制代码

平衡因子 bf = 左子树高度 - 右子树高度

合法取值：

-1：右子树更高
0：左右子树等高
1：左子树更高

失衡判定：

节点 bf = 2 或 -2 → 必须旋转修复

1.3 四种失衡类型与旋转方案

失衡类型	判定条件	旋转方式
左左失衡（LL）	parent->_bf = -2，cur->_bf = -1	右单旋
左右失衡（LR）	parent->_bf = -2，cur->_bf = 1	左右双旋
右右失衡（RR）	parent->_bf = 2，cur->_bf = 1	左单旋
右左失衡（RL）	parent->_bf = 2，cur->_bf = -1	右左双旋

二、AVL树节点结构设计

cpp 复制代码

#pragma once
#include <iostream>
#include <algorithm>
#include <utility>
using namespace std;

// AVL树节点结构
template<class K, class V>
struct AVLTreeNode
{
    // 键值对存储数据
    pair<K, V> _kv;
    // 左右孩子指针
    AVLTreeNode<K, V>* _left;
    AVLTreeNode<K, V>* _right;
    // 双亲指针，旋转与回溯核心
    AVLTreeNode<K, V>* _parent;
    // 平衡因子
    int _bf;

    // 构造函数
    AVLTreeNode(const pair<K, V>& kv)
        : _kv(kv)
        , _left(nullptr)
        , _right(nullptr)
        , _parent(nullptr)
        , _bf(0)
    {}
};

三、AVL树主体类定义

cpp 复制代码

template<class K, class V>
class AVLTree
{
    typedef AVLTreeNode<K, V> Node;

public:
    AVLTree()
        : _root(nullptr)
    {}

    // 插入接口
    bool Insert(const K& key, const V& value);
    // 右单旋
    void RotateR(Node* parent);
    // 左单旋
    void RotateL(Node* parent);
    // 左右双旋
    void RotateLR(Node* parent);
    // 右左双旋
    void RotateRL(Node* parent);
    // 求树高度
    int Height(Node* root);
    // 验证是否平衡
    bool IsBalance();
    bool _IsBalance(Node* root);
    // 中序遍历
    void InOrder();
    void _InOrder(Node* root);

private:
    Node* _root;
};

四、右单旋（RotateR）

4.1 适用场景

左左失衡（LL）：节点左子树过高，左孩子的左子树过高。

4.2 实现代码

cpp 复制代码

template<class K, class V>
void AVLTree<K, V>::RotateR(Node* parent)
{
    // 定位关键节点
    Node* subL = parent->_left;
    Node* subLR = subL->_right;
    Node* pparent = parent->_parent;

    // 旋转结构调整
    parent->_left = subLR;
    subL->_right = parent;

    // 维护双亲指针
    if (subLR)
        subLR->_parent = parent;

    parent->_parent = subL;
    subL->_parent = pparent;

    // 根节点特殊处理
    if (_root == parent)
    {
        _root = subL;
        subL->_parent = nullptr;
    }
    else
    {
        if (pparent->_left == parent)
            pparent->_left = subL;
        else
            pparent->_right = subL;
    }

    // 平衡因子重置
    subL->_bf = parent->_bf = 0;
}

五、左单旋（RotateL）

5.1 适用场景

右右失衡（RR）：节点右子树过高，右孩子的右子树过高。

5.2 实现代码

cpp 复制代码

template<class K, class V>
void AVLTree<K, V>::RotateL(Node* parent)
{
    // 定位关键节点
    Node* subR = parent->_right;
    Node* subRL = subR->_left;
    Node* pparent = parent->_parent;

    // 旋转结构调整
    parent->_right = subRL;
    subR->_left = parent;

    // 维护双亲指针
    if (subRL)
        subRL->_parent = parent;

    parent->_parent = subR;
    subR->_parent = pparent;

    // 根节点特殊处理
    if (_root == parent)
    {
        _root = subR;
        subR->_parent = nullptr;
    }
    else
    {
        if (pparent->_left == parent)
            pparent->_left = subR;
        else
            pparent->_right = subR;
    }

    // 平衡因子重置
    subR->_bf = parent->_bf = 0;
}

六、左右双旋（RotateLR）

6.1 适用场景

左右失衡（LR）：节点左子树高，左孩子的右子树高。

6.2 实现代码

cpp 复制代码

template<class K, class V>
void AVLTree<K, V>::RotateLR(Node* parent)
{
    Node* subL = parent->_left;
    Node* subLR = subL->_right;
    // 保存原平衡因子，用于修正
    int bf = subLR->_bf;

    // 旋转顺序：先左单旋左孩子，再右单旋父节点
    RotateL(subL);
    RotateR(parent);

    // 修正平衡因子
    if (bf == -1)
    {
        subL->_bf = 0;
        subLR->_bf = 0;
        parent->_bf = 1;
    }
    else if (bf == 1)
    {
        subL->_bf = -1;
        subLR->_bf = 0;
        parent->_bf = 0;
    }
    else
    {
        subL->_bf = 0;
        subLR->_bf = 0;
        parent->_bf = 0;
    }
}

七、右左双旋（RotateRL）

7.1 适用场景

右左失衡（RL）：节点右子树高，右孩子的左子树高。

7.2 实现代码

cpp 复制代码

template<class K, class V>
void AVLTree<K, V>::RotateRL(Node* parent)
{
    Node* subR = parent->_right;
    Node* subRL = subR->_left;
    // 保存原平衡因子，用于修正
    int bf = subRL->_bf;

    // 旋转顺序：先右单旋右孩子，再左单旋父节点
    RotateR(subR);
    RotateL(parent);

    // 修正平衡因子
    if (bf == -1)
    {
        subRL->_bf = 0;
        parent->_bf = 0;
        subR->_bf = 1;
    }
    else if (bf == 1)
    {
        subR->_bf = 0;
        subRL->_bf = 0;
        parent->_bf = -1;
    }
    else
    {
        subRL->_bf = 0;
        parent->_bf = 0;
        subR->_bf = 0;
    }
}

八、AVL树插入（Insert）

8.1 核心逻辑

按照BST规则找到插入位置
插入新节点并维护双亲指针
向上回溯更新平衡因子
失衡则执行对应旋转
旋转后树恢复平衡，终止回溯

8.2 完整实现代码

cpp 复制代码

template<class K, class V>
bool AVLTree<K, V>::Insert(const K& key, const V& value)
{
    // 空树直接创建根节点
    if (_root == nullptr)
    {
        _root = new Node(make_pair(key, value));
        return true;
    }

    // 查找插入位置
    Node* parent = nullptr;
    Node* cur = _root;
    while (cur)
    {
        if (key > cur->_kv.first)
        {
            parent = cur;
            cur = cur->_right;
        }
        else if (key < cur->_kv.first)
        {
            parent = cur;
            cur = cur->_left;
        }
        else
        {
            // 键值重复，插入失败
            return false;
        }
    }

    // 链接新节点
    Node* newnode = new Node(make_pair(key, value));
    if (key > parent->_kv.first)
    {
        parent->_right = newnode;
        newnode->_parent = parent;
    }
    else
    {
        parent->_left = newnode;
        newnode->_parent = parent;
    }

    // 回溯更新平衡因子 + 旋转调整
    cur = newnode;
    while (parent)
    {
        // 左插 bf--，右插 bf++
        if (parent->_left == cur)
            parent->_bf--;
        else
            parent->_bf++;

        // 平衡因子为0，高度不变，停止更新
        if (parent->_bf == 0)
        {
            break;
        }
        // 平衡因子±1，高度变化，继续向上
        else if (abs(parent->_bf) == 1)
        {
            cur = parent;
            parent = parent->_parent;
        }
        // 平衡因子±2，失衡，旋转修复
        else if (abs(parent->_bf) == 2)
        {
            if (parent->_bf == -2 && cur->_bf == -1)
            {
                RotateR(parent);
            }
            else if (parent->_bf == -2 && cur->_bf == 1)
            {
                RotateLR(parent);
            }
            else if (parent->_bf == 2 && cur->_bf == 1)
            {
                RotateL(parent);
            }
            else if (parent->_bf == 2 && cur->_bf == -1)
            {
                RotateRL(parent);
            }
            // 旋转后平衡，退出循环
            break;
        }
    }
    return true;
}

九、辅助功能实现

9.1 树高度计算

cpp 复制代码

template<class K, class V>
int AVLTree<K, V>::Height(Node* root)
{
    if (root == nullptr)
        return 0;
    int leftH = Height(root->_left);
    int rightH = Height(root->_right);
    return max(leftH, rightH) + 1;
}

9.2 平衡验证

cpp 复制代码

template<class K, class V>
bool AVLTree<K, V>::_IsBalance(Node* root)
{
    if (root == nullptr)
        return true;

    int leftH = Height(root->_left);
    int rightH = Height(root->_right);

    // 检查平衡因子是否正确
    if (abs(leftH - rightH) > 1)
    {
        cout << "节点失衡：" << root->_kv.first << endl;
        return false;
    }
    if (root->_bf != leftH - rightH)
    {
        cout << "平衡因子错误：" << root->_kv.first << endl;
        return false;
    }

    return _IsBalance(root->_left) && _IsBalance(root->_right);
}

template<class K, class V>
bool AVLTree<K, V>::IsBalance()
{
    return _IsBalance(_root);
}

9.3 中序遍历

cpp 复制代码

template<class K, class V>
void AVLTree<K, V>::_InOrder(Node* root)
{
    if (root == nullptr)
        return;
    _InOrder(root->_left);
    cout << root->_kv.first << " ";
    _InOrder(root->_right);
}

template<class K, class V>
void AVLTree<K, V>::InOrder()
{
    _InOrder(_root);
    cout << endl;
}

十、测试主函数

cpp 复制代码

int main()
{
    AVLTree<int, int> t;
    // 测试用例：有序插入，检验平衡效果
    int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    for (auto e : a)
    {
        t.Insert(e, e);
    }

    // 中序遍历（必须有序）
    cout << "中序遍历：";
    t.InOrder();

    // 验证是否平衡
    cout << "是否平衡：" << (t.IsBalance() ? "是" : "否") << endl;

    return 0;
}

十一、代码运行说明

全部代码可直接复制，保存为 AVLTree.cpp
使用VS/G++/Clang直接编译运行
中序遍历结果一定是升序序列
IsBalance() 必须返回 true，否则实现错误

十二、AVL树核心总结

12.1 旋转规则

左左 → 右单旋
右右 → 左单旋
左右 → 先左后右双旋
右左 → 先右后左双旋

12.2 插入回溯规则

bf = 0 → 停止回溯
bf = ±1 → 继续向上
bf = ±2 → 旋转 + 终止

12.3 关键细节

双亲指针必须双向维护
双旋必须保存中间节点平衡因子
旋转后必须更新根节点指针
旋转完成必须break退出循环

十三、常见面试考点

AVL树与红黑树的区别
四种失衡场景与旋转方式
平衡因子的计算与更新
旋转的时间复杂度
AVL树的应用场景
双亲指针的作用