<think>题目要求实现平衡二叉排序树（AVL树）的各种操作，并且输出格式要求严格。我们需要注意以下几点：
1.输入：第
一行是结点个数n，第二行是n个整数，第三行和第四行是两个待查找的关键字，第五行是待插入的关键字，第六行是待删除的关键字（这是新增的，注意题目描述中第六行是待删除关键字）2.输出：有20行输出，按照要求输出各种
遍历结果。我们使用AVL树来实现。AVL树在插入和删除时通过旋转操作保持平衡。需要实现以下函数：
-插入（包括旋转操作）
-删除（也包括旋转操作）
-三种递归
遍历（前序、中序、后序）
-三种非递归
遍历（前序、中序、后序）——注意题目要求输出插入新结点后的中序
遍历（非递归）和删除结点后的中序
遍历（非递归）
-层次遍历（使用队列）
-查找
-交换左右子树（递归进行）
-求深度
-叶子结点计数注意：题目要求删除结点，所以我们需要实现删除操作。步骤：
1.定义AVL树结点结构（包含值、高度、左右子结点指针）。2.实现基本的辅助函数：获取结点高度、更新高度、平衡因子计算。3.实现旋转函数：右旋、左旋。4.实现插入函数（递归），在递归回溯过程中更新高度并检查平衡，进行必要的旋转。5.实现删除函数（递归），同样需要更新高度和平衡。6.实现各种
遍历（递归和非递归）。7.主函数中按顺序处理输入，构建AVL树，进行各种操作并输出。注意：交换左右子树操作，我们采用递归方式，交换每个结点的左右子树。注意交换两次可以恢复原树。由于题目要求输出步骤较多，我们严格按照输出格式进行。注意：在删除结点后，我们还需要输出删除后的非递归中序
遍历和
层次遍历，然后再进行交换操作。另外，题目要求两次交换子树后输出
遍历序列。注意：第
一次交换后，树的结构改变；第二次交换（相当于再次交换）会恢复原来的结构（因为交换两次相当于没有交换）。所以最后输出的两次交换后的
遍历序列中，第二次交换后应该和最初的
一样。但是，注意题目最后要求输出的是
二叉树的深度和叶子结点数，应该是在删除结点后的树（未进行交换）的状态下计算。然而，仔细看输出格式：
第十九行：
二叉树的深度第二十行：叶子结点数根据输出步骤，在第二次交换后（也就是
第十六行到
第十八行）之后输出深度和叶子数。但第二次交换后，树恢复到了删除结点后的状态（因为之前有两次交换，第
一次交换后树被镜像，第二次交换又恢复）。所以实际上此时树就是删除结点后的树。因此，我们可以在第二次交换后（也就是在删除结点后的树的基础上进行了两次交换，因此树恢复原状）直接计算深度和叶子数，但注意：第
一次交换是在删除结点之后，交换操作是在删除后的树上进行的。所以第二次交换后，树的结构和删除后的树是
一样的（因为两次交换恢复），所以此时计算深度和叶子数其实就是删除结点后的树的深度和叶子数。但是，输出格式中，在第二次交换之后才输出深度和叶子数，所以我们在第二次交换后（此时树已经恢复成删除后的树）计算这些值。然而，这里有
一个问题：我们是否需要在删除后先不交换，先计算深度和叶子数？但是题目要求在第二次交换后才输出深度和叶子数。不过，交换操作并不改变深度和叶子数（因为交换左右子树并不会改变树的结构，但是会改变
遍历顺序，但深度不变，叶子节点数也不变）。所以实际上深度和叶子数在删除后就已经确定了，不受交换影响（因为交换两次后还是原来的树）。但是注意：交换子树其实会改变树的结构（变成了镜像），但是深度和叶子结点数量保持不变。所以我们可以这样：删除结点后，我们记这棵树为T。第
一次交换：T
1=swap
(T
)——T
1是T的镜像，深度和叶子数与T相同。第二次交换：T2
=swap
(T
1)——T2就是T，深度和叶子数与T相同。所以在T2上计算深度和叶子数，其实就是在T上计算。因此我们在第二次交换后（此时树已经恢复为T）再进行计算。所以，程序流程如下：
1.读取n和n个整数，构建AVL树。2.输出前序、中序、后序（递归）。3.读取两个待查找的关键字，分别输出查找结果（
1或0）。4.读取待插入关键字，插入，输出插入后的前序、中序（递归）、后序（递归）、中序（非递归）、
层次遍历。5.读取待删除关键字，删除该结点，然后输出删除后的中序（非递归）和
层次遍历。6.第
一次交换：交换所有结点的左右子树，然后输出交换后的前序、中序、后序（递归）。7.第二次交换：再次交换，然后输出交换后的前序、中序、后序（递归）。8.输出深度和叶子数（在第二次交换后，树已经恢复成删除后的树，所以计算删除后树的深度和叶子数）。注意：在删除结点后，我们的树已经变为删除后的树。然后我们进行两次交换，第二次交换后树恢复到删除后的树（因为两次交换抵消）。所以第8步的深度和叶子数就是删除后的树的深度和叶子数。但是，这里有
一个问题：题目要求输出的两次交换后的
遍历序列中，第二次交换后应该是恢复成删除后的树，所以第二次交换后的
遍历序列应该和删除后的树的
遍历序列（没有交换过的
一样）。所以我们需要在删除结点后先保存这棵树（作为T），然后进行交换操作，第
一次交换得到镜像，然后输出镜像的
遍历序列；再交换回来，得到原树（T），输出原树的
遍历序列。这样输出的第二次交换后的
遍历序列应该和删除后未交换的
遍历序列是
一样的。但是，我们并没有要求输出删除后的所有递归
遍历，所以删除后的树在删除后只输出了非递归中序和
层次遍历，然后进行了交换操作。所以第
一次交换后的
遍历序列是镜像的，而第二次交换后的
遍历序列恢复原样。所以，我们按以下步骤：
-删除结点后的树（称为T），我们暂时不输出递归
遍历，只输出非递归中序和
层次遍历。
-然后我们进行第
一次交换（得到T_mirror），然后输出T_mirror的三种递归
遍历。
-然后我们进行第二次交换（得到T，即原删除后的树），然后输出T的三种递归
遍历（应该和删除后不交换的递归
遍历一致，但题目没有要求删除后的递归
遍历，所以我们只需要按照交换操作后的树输出即可）。
-然后计算深度和叶子数（此时是T）。然而，题目要求输出的最后两行是深度和叶子数，所以我们在最后输出。但是，我们需要注意的是，在删除结点后，树就已经变成了删除后的树，然后我们进行两次交换操作，第二次交换后树恢复成删除后的树（即T），所以我们在第二次交换操作后，输出深度和叶子数。因此，代码流程：步骤
1：构建初始AVL树（root）。步骤2：输出初始的三种递归
遍历。步骤3：输出两个查找结果。步骤4：插入新节点，然后输出插入后的递归
遍历（前中后），再输出非递归中序和
层次遍历。步骤5：删除节点（第六行输入的关键字），然后输出删除后的非递归中序
遍历和
层次遍历。步骤6：第
一次交换，然后输出第
一次交换后的前序、中序、后序
遍历序列。步骤7：第二次交换（恢复），然后输出第二次交换后的前序、中序、后序
遍历序列（即删除节点后未交换的树）。步骤8：输出深度和叶子数。但是这里有
一个问题：在删除节点后，我们输出的非递归中序和
层次遍历是删除后未交换的树（T）的结果。而第
一次交换后，我们得到镜像树，所以
遍历序列会变。第二次交换后，我们又恢复成T。注意：交换两次后，树恢复原状，所以第二次交换后的
遍历序列应该和删除后未交换的树的
遍历序列
一样（也就是和步骤5中我们输出的非递归中序和
层次遍历的前序、中序、后序递归
遍历版本
一致吗？）但是步骤5中我们只输出了非递归中序和
层次遍历，没有输出递归的三序
遍历，所以这里我们按照要求输出两次交换后的递归三序
遍历。因此，在步骤7中，我们输出第二次交换后的前序、中序、后序递归
遍历，也就是删除节点后的树的递归三序
遍历。所以，整个流程就符合题目要求了。我们开始实现代码：注意：非递归后序
遍历较为复杂，我们采用
一个栈和
一个指针指向前
一个访问的结点来实现。另外，删除操作中，如果需要删除的结点有两个子结点，我们使用右子树的最小值结点来替代被删除结点。由于题目要求严格，我们必须保证输出格式正确。下面我们写代码。</think>
以下是
一个完整的平衡二叉排序树（AVL树）实现，满足所有要求的操作和输出格式：
```cpp
#include <iostream>
#include <vector>
#include <queue>
#include <stack>
#include <algorithm>
using namespace std;
struct TreeNode {
int val;
int height; // 节点高度，用于平衡因子计算
TreeNode *left;
TreeNode *right;
TreeNode
(int x
) : val
(x
), height
(1), left
(nullptr
), right
(nullptr
) {}
};
// 获取节点高度
int getHeight
(TreeNode* node
) {
return node ? node
->height : 0;
}
// 更新节点高度
void updateHeight
(TreeNode* node
) {
node
->height
= max
(getHeight
(node
->left
), getHeight
(node
->right
)) +
1;
}
// 计算平衡因子
int getBalanceFactor
(TreeNode* node
) {
return getHeight
(node
->left
) - getHeight
(node
->right
);
}
// 右旋操作
TreeNode* rightRotate
(TreeNode* y
) {
TreeNode* x
= y
->left;
TreeNode* T
= x
->right;
x
->right
= y;
y
->left
= T;
updateHeight
(y
);
updateHeight
(x
);
return x;
}
// 左旋操作
TreeNode* leftRotate
(TreeNode* x
) {
TreeNode* y
= x
->right;
TreeNode* T
= y
->left;
y
->left
= x;
x
->right
= T;
updateHeight
(x
);
updateHeight
(y
);
return y;
}
// 平衡
二叉树插入
TreeNode* insert
(TreeNode* root, int key
) {
if
(!root
) return new TreeNode
(key
);
if
(key < root
->val
) {
root
->left
= insert
(root
->left, key
);
} else if
(key > root
->val
) {
root
->right
= insert
(root
->right, key
);
} else {
return root; // 重复值不插入
}
updateHeight
(root
);
int balance
= getBalanceFactor
(root
);
// 左左情况
if
(balance >
1 && key < root
->left
->val
) {
return rightRotate
(root
);
}
// 右右情况
if
(balance <
-1 && key > root
->right
->val
) {
return leftRotate
(root
);
}
// 左右情况
if
(balance >
1 && key > root
->left
->val
) {
root
->left
= leftRotate
(root
->left
);
return rightRotate
(root
);
}
// 右左情况
if
(balance <
-1 && key < root
->right
->val
) {
root
->right
= rightRotate
(root
->right
);
return leftRotate
(root
);
}
return root;
}
// 找到最小值节点（后继）
TreeNode* minValueNode
(TreeNode* node
) {
TreeNode* current
= node;
while
(current && current
->left
)
current
= current
->left;
return current;
}
// 平衡删除节点
TreeNode* deleteNode
(TreeNode* root, int key
) {
if
(!root
) return root;
if
(key < root
->val
) {
root
->left
= deleteNode
(root
->left, key
);
} else if
(key > root
->val
) {
root
->right
= deleteNode
(root
->right, key
);
} else {
if
(!root
->left || !root
->right
) {
TreeNode* temp
= root
->left ? root
->left : root
->right;
delete root;
return temp;
} else {
TreeNode* temp
= minValueNode
(root
->right
);
root
->val
= temp
->val;
root
->right
= deleteNode
(root
->right, temp
->val
);
}
}
if
(!root
) return root; // 删除后为空
updateHeight
(root
);
int balance
= getBalanceFactor
(root
);
// 左左情况
if
(balance >
1 && getBalanceFactor
(root
->left
) >
= 0
) {
return rightRotate
(root
);
}
// 左右情况
if
(balance >
1 && getBalanceFactor
(root
->left
) < 0
) {
root
->left
= leftRotate
(root
->left
);
return rightRotate
(root
);
}
// 右右情况
if
(balance <
-1 && getBalanceFactor
(root
->right
) <
= 0
) {
return leftRotate
(root
);
}
// 右左情况
if
(balance <
-1 && getBalanceFactor
(root
->right
) > 0
) {
root
->right
= rightRotate
(root
->right
);
return leftRotate
(root
);
}
return root;
}
// 递归先序
遍历
vector<int> preorderRecursive
(TreeNode* root
) {
vector<int> res;
if
(root
) {
res.push_back
(root
->val
);
vector<int> left
= preorderRecursive
(root
->left
);
vector<int> right
= preorderRecursive
(root
->right
);
res.insert
(res.end
(), left.begin
(), left.end
());
res.insert
(res.end
(), right.begin
(), right.end
());
}
return res;
}
// 非递归先序
遍历
vector<int> preorderIterative
(TreeNode* root
) {
vector<int> res;
if
(!root
) return res;
stack<TreeNode*> st;
st.push
(root
);
while
(!st.empty
()) {
TreeNode* node
= st.top
();
st.pop
();
res.push_back
(node
->val
);
if
(node
->right
) st.push
(node
->right
);
if
(node
->left
) st.push
(node
->left
);
}
return res;
}
// 递归中序
遍历
vector<int> inorderRecursive
(TreeNode* root
) {
vector<int> res;
if
(root
) {
vector<int> left
= inorderRecursive
(root
->left
);
res.insert
(res.end
(), left.begin
(), left.end
());
res.push_back
(root
->val
);
vector<int> right
= inorderRecursive
(root
->right
);
res.insert
(res.end
(), right.begin
(), right.end
());
}
return res;
}
// 非递归中序
遍历
vector<int> inorderIterative
(TreeNode* root
) {
vector<int> res;
stack<TreeNode*> st;
TreeNode* curr
= root;
while
(curr || !st.empty
()) {
while
(curr
) {
st.push
(curr
);
curr
= curr
->left;
}
curr
= st.top
();
st.pop
();
res.push_back
(curr
->val
);
curr
= curr
->right;
}
return res;
}
// 递归后序
遍历
vector<int> postorderRecursive
(TreeNode* root
) {
vector<int> res;
if
(root
) {
vector<int> left
= postorderRecursive
(root
->left
);
vector<int> right
= postorderRecursive
(root
->right
);
res.insert
(res.end
(), left.begin
(), left.end
());
res.insert
(res.end
(), right.begin
(), right.end
());
res.push_back
(root
->val
);
}
return res;
}
// 非递归后序
遍历
vector<int> postorderIterative
(TreeNode* root
) {
vector<int> res;
if
(!root
) return res;
stack<TreeNode*> st;
TreeNode* lastVisited
= nullptr;
TreeNode* curr
= root;
while
(!st.empty
() || curr
) {
if
(curr
) {
st.push
(curr
);
curr
= curr
->left;
} else {
TreeNode* top
= st.top
();
if
(top
->right && lastVisited !
= top
->right
) {
curr
= top
->right;
} else {
res.push_back
(top
->val
);
lastVisited
= top;
st.pop
();
}
}
}
return res;
}
//
层次遍历
vector<int> levelOrder
(TreeNode* root
) {
vector<int> res;
if
(!root
) return res;
queue<TreeNode*> q;
q.push
(root
);
while
(!q.empty
()) {
TreeNode* node
= q.
front();
q.pop
();
res.push_back
(node
->val
);
if
(node
->left
) q.push
(node
->left
);
if
(node
->right
) q.push
(node
->right
);
}
return res;
}
// 查找节点
int search
(TreeNode* root, int key
) {
TreeNode* curr
= root;
while
(curr
) {
if
(key
== curr
->val
) return
1;
curr
= (key < curr
->val
) ? curr
->left : curr
->right;
}
return 0;
}
// 交换子树
TreeNode* swapTree
(TreeNode* root
) {
if
(!root
) return nullptr;
swap
(root
->left, root
->right
);
swapTree
(root
->left
);
swapTree
(root
->right
);
return root;
}
// 计算树深度
int depth
(TreeNode* root
) {
return root ?
1 + max
(depth
(root
->left
), depth
(root
->right
)) : 0;
}
// 计算叶子节点数
int leafCount
(TreeNode* root
) {
if
(!root
) return 0;
if
(!root
->left && !root
->right
) return
1;
return leafCount
(root
->left
) + leafCount
(root
->right
);
}
// 打印vector内容
void printVector
(const vector<int>& v
) {
for
(int i
= 0; i < v.size
(); i++
) {
if
(i > 0
) cout << " ";
cout << v[i];
}
cout << endl;
}
int main
() {
int n;
cin >> n;
vector<int> keys
(n
);
for
(int i
= 0; i < n; i++
) {
cin >> keys[i];
}
int target
1, target2, insertKey, deleteKey;
cin >> target
1 >> target2 >> insertKey >> deleteKey;
// 构建初始AVL树
TreeNode* root
= nullptr;
for
(int key : keys
) {
root
= insert
(root, key
);
}
//
1-3行：初始
遍历序列（前序、中序、后序）
printVector
(preorderRecursive
(root
));
printVector
(inorderRecursive
(root
));
printVector
(postorderRecursive
(root
));
// 4
-5行：查找结果
cout << search
(root, target
1) << endl;
cout << search
(root, target2
) << endl;
// 6
-8行：插入新节点后的
遍历序列
root
= insert
(root, insertKey
);
printVector
(preorderRecursive
(root
));
printVector
(inorderRecursive
(root
));
printVector
(postorderRecursive
(root
));
// 9行：插入后的非递归中序
printVector
(inorderIterative
(root
));
//
10行：插入后的
层次遍历
printVector
(levelOrder
(root
));
//
11行：删除后的非递归中序
root
= deleteNode
(root, deleteKey
);
printVector
(inorderIterative
(root
));
//
12行：删除后的
层次遍历
printVector
(levelOrder
(root
));
//
13
-15行：第
一次交换后的
遍历序列
root
= swapTree
(root
);
printVector
(preorderRecursive
(root
));
printVector
(inorderRecursive
(root
));
printVector
(postorderRecursive
(root
));
//
16
-18行：第二次交换后的
遍历序列（恢复原树）
root
= swapTree
(root
);
printVector
(preorderRecursive
(root
));
printVector
(inorderRecursive
(root
));
printVector
(postorderRecursive
(root
));
//
19行：树的深度
cout << depth
(root
) << endl;
// 20行：叶子节点数
cout << leafCount
(root
) << endl;
return 0;
}
```
###
算法详解
1. **AVL树平衡机制**：
- 使用高度平衡因子维护平衡
- 实现4种旋转操作：左旋、右旋、左右旋、右左旋
- 插入和删除时自动调整平衡
2. **
遍历算法实现**：
- 递归
遍历：直接按
遍历顺序递归处理子树
- 非递归
遍历：
- 前序：使用栈，按根
->右
->左顺序入栈
- 中序：使用栈模拟递归调用顺序
- 后序：使用辅助指针标记最后访问节点
3. **特殊操作**：
- 交换子树：递归交换所有节点的左右子树
- 深度计算：递归计算左右子树最大深度
- 叶子计数：递归统计无子节点的节点数
- 删除节点：处理三种情况（无子、单子、双子节点）
4. **主要函数说明**：
- `insert
()`：平衡插入，保持AVL树特性
- `deleteNode
()`：平衡删除，考虑多种情况
- `search
()`：基于BST特性高效查找
- `levelOrder
()`：BFS实现
层次遍历
本文介绍了一种实现二叉树层次遍历的算法，并通过具体示例“A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))”展示了如何使用环形队列来实现这一过程。
扫一扫
273
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
