easy 剑指 Offer 二叉树的镜像 递归 DFS 栈 BFS

---

递归 （深度优先搜索 DFS）：

c++

class Solution {
public:
    TreeNode* mirrorTree(TreeNode* root) {
        if(root == nullptr){
            return nullptr;
        }
        // 交换该根节点左右树
        TreeNode* temp = root->left;
        root->left = root->right;
        root->right = temp;
        
        // 交换该根节点的 左右节点的左右树
        mirrorTree(root->left);
        mirrorTree(root->right);

        return root; // 返回已经交换完下面所有节点 的根节点
    }
};

python

class Solution:
    def mirrorTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return None
        #  交换该根节点左右树
        temp = root.left
        root.left = root.right
        root.right = temp

        #  交换该根节点的 左右节点的左右树
        self.mirrorTree(root.left)
        self.mirrorTree(root.right)

        return root

---

栈（BFS 广度优先搜索）：

广度优先搜索的 队列/栈 里存放的是「当前层的所有节点」

C++

class Solution {
public:
    TreeNode* mirrorTree(TreeNode* root) {
        if(root == nullptr){
            return nullptr;
        }
        stack<TreeNode*> stack;
        stack.push(root);

        //广度优先搜索的 队列/栈 里存放的是「当前层的所有节点」
        while (!stack.empty()){
            // 当前出栈节点
            TreeNode* node = stack.top();
            stack.pop();

            // 下一层节点放入栈中
            if (node->left != nullptr){
                stack.push(node->left);
            }
            if (node->right != nullptr){
                stack.push(node->right);
            }

            // 处理当前出栈节点
            TreeNode* tmp = node->left;
            node->left = node->right;
            node->right = tmp;
        }

        return root;
    }
};

python

class Solution:
    def mirrorTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return None
        
        stk = [root]
        while stk:
            #  当前出栈节点
            node = stk.pop()  # python stack.pop() 返回 stack.top() 并删除

            #  当前出栈节点 下一层节点加入栈
            if node.left:
                stk.append(node.left)
            if node.right:
                stk.append(node.right)

            # 处理当前出栈节点
            node.left, node.right = node.right, node.left

        return root

---