代码函数功能顺序如下：
1：destroy：递归删除树
2：copy：复制二叉树
3：preOrder：递归前序遍历
4：inOrder：递归中序遍历
5：postOrder：递归后续遍历
6：levelOrder：BFS层序遍历
7：mergeTrees：合并树
8：getRoot：获取根节点
cpp
#include <bits/stdc++.h>
using namespace std;
struct TreeNode
{
int val; // 节点值
TreeNode *left; // 左子树
TreeNode *right; // 右子树
TreeNode(int x) // 构造函数
{
val = x;
left = nullptr;
right = nullptr;
}
};
// class定义类
class BinaryTree
{
private:
TreeNode *root; // 定义根节点，根节点是私有的，外部不能直接访问
// 递归删除树
void destroy(TreeNode *node) // 参数是正在处理的二叉树结点
{
if (node) // 在节点存在（不为空）的情况下
{
destroy(node->left); // 递归删除左子树
destroy(node->right); // 递归删除右子树
delete node; // 删除当前节点
}
}
// 递归复制二叉树
TreeNode *copy(TreeNode *node) // 输入原二叉树的某个结点指针
// 返回复制后的新二叉树对应节点指针
{
if (!node)
{
return nullptr;
}
TreeNode *newNode = new TreeNode(node->val);
newNode->left = copy(node->left);
newNode->right = copy(node->right);
return newNode;
}
public:
BinaryTree() : root(nullptr) {}
// 构造函数，初始化根节点为空
// 递归前序遍历
void preOrder(TreeNode *node = nullptr)
{
if (!node) // 如果当前是空节点，则返回
{
// 如果当前节点为空，停止递归
if (!root)
{
return;
}
node = root; // 如果当前节点不为空，则将当前节点设为根节点
}
cout << node->val << " "; // 输出当前节点值
if (node->left)
{
preOrder(node->left); // 递归遍历左子树
}
if (node->right)
{
preOrder(node->right); // 递归遍历右子树
}
}
// 递归中序遍历
void inOrder(TreeNode *node = nullptr)
{
if (!node)
{
if (!root)
{
return;
}
node = root;
}
if (node->left)
{
inOrder(node->left);
}
cout << node->val << " ";
if (node->right)
{
inOrder(node->right);
}
}
// 递归后序遍历
void postOrder(TreeNode *node = nullptr)
{
if (!node)
{
if (!root)
{
return;
}
node = root;
}
if (node->left)
{
postOrder(node->left);
}
if (node->right)
{
postOrder(node->right);
}
cout << node->val << " ";
}
// 层序遍历(BFS)
void levelOrder(const vector<int> &nodes) // 参数用来存储二叉树的层序遍历序列
{
if (nodes.empty() || nodes[0] == -1)
{
root = nullptr;
return;
}
root = new TreeNode(nodes[0]);
// 根节点是第一个元素
queue<TreeNode *> q;
// 使用队列进行层序遍历
q.push(root);
// 放入第一个元素
int i = 1;
while (!q.empty() && i < nodes.size())
{
TreeNode *current = q.front();
// 获取当前节点,起名为current
q.pop(); // 弹出队头
if (i < nodes.size() && nodes[i] != -1)
{ // 如果当前节点有左子树
current->left = new TreeNode(nodes[i]);
// 创建左子树，值为nodes[i]
q.push(current->left);
// 将左子树放入队列
}
i++; // i指向下一个元素
// 右子树同理
if (i < nodes.size() && nodes[i] != -1)
{
current->right = new TreeNode(nodes[i]);
q.push(current->right);
}
i++;
}
}
// 合并两棵树
// void，直接修改当前数的值，把他与other合并
// other树会清空(root指针被设为nullptr)
void mergeTrees(BinaryTree &other, int mergeValue)
{
// 参数other是另一个二叉树，mergeValue是合并后的新根节点的值
if (!root)
{
root = other.root; // 如果当前树为空，直接将other树赋值给当前树
other.root = nullptr; // other树清空
return;
}
TreeNode *newRoot = new TreeNode(mergeValue);
// 创建新根节点,值为mergeValue,作为合并后的根节点
newRoot->left = root;
// 新根节点的左子树为当前树的根节点
newRoot->right = other.root;
// 新根节点的右子树为other树的根节点
root = newRoot;
// 将新根节点赋值给当前树的根节点
other.root = nullptr;
// other树清空
}
// 析构函数
~BinaryTree() { destroy(root); } // 析构函数，删除树
// 获取根节点
TreeNode *getRoot() { return root; } // 获取根节点
};
int main()
{
// 测试1: 构造空树
BinaryTree emptyTree;
cout << "Empty tree pre-order: ";
emptyTree.preOrder(); // 应无输出
cout << endl;
// 测试2: 从层序遍历数组构造二叉树
vector<int> nodes1 = {1, 2, 3, -1, 4, 5, 6}; // -1表示空节点
BinaryTree tree1;
tree1.levelOrder(nodes1); // 构建树
cout << "Tree1 Pre-order(recursive): ";
tree1.preOrder();
cout << endl;
cout << "Tree1 In-order(recursive): ";
tree1.inOrder();
cout << endl;
cout << "Tree1 Post-order(recursive): ";
tree1.postOrder();
cout << endl;
// 测试3: 复制构造函数
BinaryTree tree2;
tree2.levelOrder({10, 11, 12, 13, -1, 14}); // 构建另一棵树
cout << "\nTree2 Level-order built: 10,11,12,13,-1,14" << endl;
cout << "Tree2 Pre-order: ";
tree2.preOrder();
cout << endl;
// 测试4: 合并两棵树
cout << "\nMerging Tree1 and Tree2 with new root value 100..." << endl;
tree1.mergeTrees(tree2, 100);
cout << "Merged Tree Pre-order: ";
tree1.preOrder(); // 应显示: 100 1 2 4 3 5 6 10 11 13 12 14
cout << endl;
// 测试5: 检查tree2是否被清空
cout << "\nTree2 after merging (should be empty): ";
tree2.preOrder(); // 应无输出
cout << endl;
// 测试6: 析构函数(自动调用，无需显式测试)
cout << "\nAll trees will be automatically destroyed when exiting main()" << endl;
return 0;
}