操作给定的二叉树，将其变换为源二叉树的镜像。_题目描述操作给定的二叉树,将其变换为源二叉树的镜像。输入描述: 二叉树的镜像-优快云博客

本文链接：https://blog.youkuaiyun.com/flyingsbird/article/details/79536306

本文介绍了一种使用前序遍历和中序遍历构造二叉树的方法，并实现了一个翻转二叉树的算法。通过具体示例展示了如何构建二叉树，以及翻转前后二叉树的先序和中序遍历结果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#include <iostream>

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
    val(x), left(NULL), right(NULL) {
    }
};

class Solution {
public:
    void Mirror(TreeNode *pRoot) {
        TreeNode *tmpNode;
        if (pRoot == NULL)
        {
            return;
        }
        if (pRoot->left || pRoot->right)
        {
            tmpNode = pRoot->left;
            pRoot->left = pRoot->right;
            pRoot->right = tmpNode;

            if (pRoot->left)
            {
                Mirror(pRoot->left);
            }
            if (pRoot->right)
            {
                Mirror(pRoot->right);
            }
        }
    }

    TreeNode* ConstructT(int *preorder, int *inorder, int len)
    {
        TreeNode* pRoot = (TreeNode*)malloc(sizeof(TreeNode));
        int index = 0;
        while (inorder[index] != preorder[0] && index < len)
        {
            index++;
        }
        if (index == len)
        {
            return NULL;
        }
        pRoot->val = preorder[0];
        pRoot->left = ConstructT(preorder + 1, inorder, index);
        pRoot->right = ConstructT(preorder + index + 1, inorder + index + 1, len - index - 1);

        return pRoot;
    }

    void PrintPreorder(TreeNode *pRoot)
    {
        if (pRoot)
        {
            std::cout << pRoot->val << " ";
            PrintPreorder(pRoot->left);
            PrintPreorder(pRoot->right);
        }
    }

    void PrintInorder(TreeNode *pRoot)
    {
        if (pRoot)
        {
            PrintInorder(pRoot->left);
            std::cout << pRoot->val << " ";
            PrintInorder(pRoot->right);
        }
    }
};

int main()
{
    Solution s;
    TreeNode * pRoot;
    int preorder[] = {8, 6, 5, 7, 10, 9, 11};
    int inorder[] = { 5, 6, 7, 8, 9, 10, 11 };
    int len = 7;

    pRoot = s.ConstructT(preorder, inorder, len);

    s.PrintPreorder(pRoot);
    std::cout << std::endl;
    s.PrintInorder(pRoot);
    std::cout << std::endl;

    s.Mirror(pRoot);

    s.PrintPreorder(pRoot);
    std::cout << std::endl;
    s.PrintInorder(pRoot);
    std::cout << std::endl;

    system("pause");

    return 0;
}