牛客题解 | 二叉树的镜像

import java.util.*;
public class Solution {
    public TreeNode Mirror (TreeNode pRoot) {
        //空树返回
        if(pRoot == null) 
            return null;
        //先递归子树
        TreeNode left = Mirror(pRoot.left);  
        TreeNode right = Mirror(pRoot.right);
        //交换
        pRoot.left = right; 
        pRoot.right = left;
        return pRoot;
    }
}

C++实现代码：

class Solution {
public:
    TreeNode* Mirror(TreeNode* pRoot) {
        //空树返回
        if(pRoot == NULL) 
            return NULL;
        //先递归子树
        TreeNode* left = Mirror(pRoot->left);  
        TreeNode* right = Mirror(pRoot->right);
        //交换
        pRoot->left = right; 
        pRoot->right = left;
        return pRoot;
    }
};

Python实现代码

class Solution:
    def Mirror(self , pRoot: TreeNode) -> TreeNode:
        # 空树返回
        if not pRoot: 
            return None
        # 先递归子树
        left = self.Mirror(pRoot.left) 
        right = self.Mirror(pRoot.right)
        # 交换
        pRoot.left = right 
        pRoot.right = left
        return pRoot

复杂度分析：

时间复杂度： $O (n)$ ，其中 $n$ 为二叉树的节点数，访问二叉树所有节点各一次
空间复杂度： $O (n)$ ，最坏情况下，二叉树退化为链表，递归栈最大值为 $n$

方法二：栈（扩展思路）

知识点：栈

栈是一种仅支持在表尾进行插入和删除操作的线性表，这一端被称为栈顶，另一端被称为栈底。元素入栈指的是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；元素出栈指的是从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

思路：

二叉树中能够用递归的，我们大多也可以用栈来实现。栈的访问是一种自顶向下的访问，因此我们需要在左右子节点入栈后直接交换，然后再访问后续栈中内容。

具体做法：

step 1：优先检查空树的情况。
step 2：使用栈辅助遍历二叉树，根节点先进栈。
step 3：遍历过程中每次弹出栈中一个元素，然后该节点左右节点分别入栈。
step 4：同时我们交换入栈两个子节点的值，因为子节点已经入栈了再交换，就不怕后续没有交换。

图示：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Java实现代码：

import java.util.*;
public class Solution {
    public TreeNode Mirror (TreeNode pRoot) {
        //空树
        if(pRoot == null)  
            return null;
        //辅助栈
        Stack<TreeNode> s = new Stack<TreeNode>(); 
        //根节点先进栈
        s.push(pRoot); 
        while (!s.isEmpty()){ 
            TreeNode node = s.pop();
            //左右节点入栈
            if(node.left != null) 
                s.push(node.left);
            if(node.right != null) 
                s.push(node.right);
            //交换左右
            TreeNode temp = node.left; 
            node.left = node.right;
            node.right = temp;
        }
        return pRoot;
    }
}

C++实现代码：

class Solution {
public:
    TreeNode* Mirror(TreeNode* pRoot) {
        //空树
        if(pRoot == NULL)  
            return NULL;
        //辅助栈
        stack<TreeNode*> s; 
        //根节点先进栈
        s.push(pRoot); 
        while (!s.empty()){
            TreeNode* node = s.top();
            s.pop();
            //左右节点入栈
            if (node->left != NULL) s.push(node->left); 
            if (node->right != NULL) s.push(node->right);
            //交换左右 
            TreeNode* temp = node->left;  
            node->left = node->right;
            node->right = temp;
        }
        return pRoot;
    }
};

Python实现代码

class Solution:
    def Mirror(self , pRoot: TreeNode) -> TreeNode:
        # 空树
        if not pRoot:  
            return None
        # 辅助栈
        s = [] 
        # 根节点先进栈
        s.append(pRoot) 
        while s:
            node = s[-1]
            s.pop()
            if node.left:
                # 左右节点入栈
                s.append(node.left) 
            if node.right:
                s.append(node.right)
            # 交换左右
            temp = node.left  
            node.left = node.right
            node.right = temp
        return pRoot