27 二叉树的镜像

题目

请完成一个函数，输入一个二叉树，该函数输出它的镜像。例如下图所示，左图是原二叉树，而右图则是该二叉树的镜像。

牛客网 OJ
AcWing Oj

C++ 题解

• 先序遍历原二叉树的每个节点，如果遍历到的结点有子结点，就交换它的两个子结点。
• 递归遍历每个节点的子节点，同样，如果遍历到的子节点有子节点，就交换它的两个子节点。

当交换完所有非叶子结点的左右子结点之后，就得到了树的镜像。下图展示了求二叉树的镜像的过程：

方法一

使用递归实现：

/*
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) {
        if(pRoot != NULL)
        {
            // 交换左右子节点
            TreeNode * pTemp = pRoot->left;
            pRoot->left = pRoot->right;
            pRoot->right = pTemp; 
            
            // 如果左子树存在，则对左子树进行递归
            if(pRoot->left != NULL)
                Mirror(pRoot->left);
            // 如果右子树存在，则对右子树进行递归
            if(pRoot->right != NULL)
                Mirror(pRoot->right);
        }
    }
};

方法二

使用非递归借助栈来实现：

/*
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) {
        if (pRoot == NULL)
            return;
        
        // 创建一个栈，用于存放根节点
        stack<TreeNode*> Treestack;
        Treestack.push(pRoot);
        
        while(Treestack.size())
        {
            TreeNode* pNode = Treestack.top();
            Treestack.pop();
            // 左右节点至少存在一个时，就要对齐进行交换
            if(pNode->left || pNode->right)
            {
                TreeNode* ptmp = pNode->left;
                pNode->left = pNode->right;
                pNode->right = ptmp;
            }
            // 如果左节点存在，那么就将左节点入栈
            if(pNode->left)
                Treestack.push(pNode->left);
            // 如果右节点存在，那么就将右节点入栈
            if(pNode->right)
                Treestack.push(pNode->right);
        }        
    }
};

python 题解

方法一

递归实现：

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回镜像树的根节点
    def Mirror(self, root):
        # write code here
        if  root != None:
            ptemp = root.left
            root.left = root.right
            root.right = ptemp
            
            if  root.left != None:
                self.Mirror(root.left)
            
            if  root.right != None:
                self.Mirror(root.right)

方法二

采用非递归的方法实现：

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回镜像树的根节点
    def Mirror(self, root):
        # write code here
        if root == None:
            return 
        alist = []
        alist.append(root)
        
        while alist != []: 
            tmpRoot = alist.pop()
            
            if tmpRoot.left != None or tmpRoot.right != None:
                tmp = tmpRoot.left
                tmpRoot.left = tmpRoot.right
                tmpRoot.right = tmp
            if tmpRoot.left != None:
                alist.append(tmpRoot.left)
            if tmpRoot.right != None:
                alist.append(tmpRoot.right)