剑指 Offer 27. 二叉树的镜像||力扣226. 翻转二叉树

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

---

分析：该题比较简单，在该节点及左右节点存在的情况下只需要交换当前节点的左右节点，循环迭代即可

方法一：递归法
        根据二叉树镜像的定义，考虑递归遍历（dfs）二叉树，交换每个节点的左 / 右子节点，即可生成二叉树的镜像。
        递归解析：
                终止条件：当节点 root 为空时（即越过叶节点），则返回 null ；
                递推工作：
                                初始化节点 tmp ，用于暂存 root 的左子节点；
                                开启递归 右子节点 mirrorTree(root.right) ，并将返回值作为 troot 的 左子节点 。
                                开启递归 左子节点 mirrorTree(tmp) ，并将返回值作为 root 的 右子节点 。
                返回值： 返回当前节点 root；

        简洁的代码：

class Solution {
public:
    TreeNode* mirrorTree(TreeNode* root) {
        if (root == nullptr) return nullptr;
        TreeNode* tmp = root->left;
        root->left = mirrorTree(root->right);
        root->right = mirrorTree(tmp);
        return root;
    }
};

class Solution {
public:
    TreeNode* mirrorTree(TreeNode* root) {
        recur(root);
        return root;
    }
    TreeNode* recur(TreeNode * head){
        TreeNode *temp = nullptr;
        if(head == nullptr)return head;
        //if(head->left!=nullptr || head->right!=nullptr){
        
        temp = head->left;
        head->left = head->right;
        head->right = temp;
        recur(head->left);
        recur(head->right);

        //}
        return head;
    }
};

方法二：辅助队列/栈（BFS层序遍历）
        利用栈（或队列）遍历树的所有节点 node，并交换每个 node 的左 / 右子节点。
        算法流程：
                特例处理： 当 root为空时，直接返回 null；
                初始化： 栈（或队列），本文用栈，并加入根节点 root 。
                循环交换： 当栈 stack 为空时跳出；
                出栈： 记为 node ；
                添加子节点： 将 node 左和右子节点入栈；
                交换： 交换 node 的左 / 右子节点。
                返回值： 返回根节点 root。

队列 queue

class Solution {
public:
    TreeNode* mirrorTree(TreeNode* root) {
        if(root==nullptr)return root;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            TreeNode* head = que.front();
            que.pop();
            if(head->left!=nullptr)que.push(head->left);
            if(head->right!=nullptr)que.push(head->right);
            TreeNode *temp = head->left;
            head->left = head->right;
            head->right = temp;
        }
        return root;
    }
};

栈stack

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;
    }
};