编写数据结构完整代码,实现在以二叉链表存储的二叉树中，交换二叉树各结点的左右子树

以下是实现在以二叉链表存储的二叉树中，交换二叉树各结点的左右子树的完整代码：

#include <iostream>
using namespace std;

// 二叉树结点定义
struct TreeNode
{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
};

// 二叉树类定义
class BinaryTree
{
public:
    // 构造函数
    BinaryTree(): root(nullptr) {}

    // 析构函数
    ~BinaryTree()
    {
        destroyTree(root);
    }

    // 插入结点
    void insert(int val)
    {
        if (root == nullptr)
        {
            root = new TreeNode(val);
            return;
        }

        TreeNode* cur = root;
        while (cur != nullptr)
        {
            if (val < cur->val)
            {
                if (cur->left == nullptr)
                {
                    cur->left = new TreeNode(val);
                    return;
                }
                else
                {
                    cur = cur->left;
                }
            }
            else
            {
                if (cur->right == nullptr)
                {
                    cur->right = new TreeNode(val);
                    return;
                }
                else
                {
                    cur = cur->right;
                }
            }
        }
    }

    // 交换左右子树
    void swapTree()
    {
        swapTreeHelper(root);
    }

    // 中序遍历
    void inorderTraversal()
    {
        inorderTraversalHelper(root);
    }

private:
    // 递归销毁二叉树
    void destroyTree(TreeNode* root)
    {
        if (root != nullptr)
        {
            destroyTree(root->left);
            destroyTree(root->right);
            delete root;
        }
    }

    // 递归交换左右子树
    void swapTreeHelper(TreeNode* root)
    {
        if (root != nullptr)
        {
            TreeNode* temp = root->left;
            root->left = root->right;
            root->right = temp;

            swapTreeHelper(root->left);
            swapTreeHelper(root->right);
        }
    }

    // 递归中序遍历
    void inorderTraversalHelper(TreeNode* root)
    {
        if (root != nullptr)
        {
            inorderTraversalHelper(root->left);
            cout << root->val << " ";
            inorderTraversalHelper(root->right);
        }
    }

    TreeNode* root; // 二叉树根节点指针
};

int main()
{
    BinaryTree bt;

    // 插入结点
    bt.insert(4);
    bt.insert(2);
    bt.insert(7);
    bt.insert(1);
    bt.insert(3);
    bt.insert(6);
    bt.insert(9);

    // 中序遍历
    cout << "Original Inorder Traversal: ";
    bt.inorderTraversal();
    cout << endl;

    // 交换左右子树
    bt.swapTree();

    // 中序遍历
    cout << "Swapped Inorder Traversal: ";
    bt.inorderTraversal();
    cout << endl;

    return 0;
}