【剑指offer】12.二叉树的镜像

总目录：

算法之旅导航目录

 

1.问题描述

操作给定的二叉树，将其变换为源二叉树的镜像。

数据范围：二叉树的节点数 0≤n≤1000 ， 二叉树每个节点的值 0≤val≤1000

要求： 空间复杂度 O(n)。本题也有原地操作，即空间复杂度 O(1)的解法，时间复杂度 O(n)

 

2.问题分析

 1用递归，逐个交换节点的左右子节点即可

2用辅助队列，还是对每个节点交换左右子节点

3.代码实例

递归

/**
 * struct TreeNode {
 *    int val;
 *    struct TreeNode *left;
 *    struct TreeNode *right;
 *    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pRoot TreeNode类 
     * @return TreeNode类
     */
    TreeNode* Mirror(TreeNode* pRoot) {
        //中止条件
        if(!pRoot){
            return NULL;
        }

        //本层逻辑,交换当前节点的左右节点
        TreeNode* tmp=pRoot->left;
        pRoot->left=pRoot->right;
        pRoot->right=tmp;

        //调用递归
        Mirror(pRoot->left);
        Mirror(pRoot->right);

        return pRoot;
    }
};

队列

/**
 * struct TreeNode {
 *  int val;
 *  struct TreeNode *left;
 *  struct TreeNode *right;
 *  TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
  public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param pRoot TreeNode类
     * @return TreeNode类
     */
    TreeNode* Mirror(TreeNode* pRoot) {
        //空树
        if (!pRoot) {
            return NULL;
        }

        //初始化队列
        queue<TreeNode*> q;
        q.push(pRoot);

        //初始化当前层节点计数器
        int nodeCount = 0;

        //逐层迭代
        while (!q.empty()) {
            //遍历当前层的所有节点
            nodeCount = q.size();
            for (int i = 0; i < nodeCount; i++) {
                auto* pNode = q.front();
                q.pop();

                //本层逻辑,交换当前节点的左右节点
                TreeNode* tmp = pNode->left;
                pNode->left = pNode->right;
                pNode->right = tmp;

                if (pNode->left) q.push(pNode->left);
                if (pNode->right) q.push(pNode->right);
            }

            //本层结束
        }
        return pRoot;
    }
};