JZ18 剑指offer 二叉树的镜像

第18题 二叉树的镜像

题目描述

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

广度优先搜索：

/*
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) return;
        queue<TreeNode*> q;
        q.push(pRoot);
        while(!q.empty()){
            int sz = q.size();
            while(sz--){
                TreeNode* node = q.front();
                q.pop();
                TreeNode* cur = node->left;
                node->left = node->right;
                node->right = cur;
                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
            }
        }
    }
};

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
import queue
class Solution:
    def mirrorTree(self, root: TreeNode) -> TreeNode:
        q = queue.Queue()
        if root: q.put(root)
        while not q.empty():
            node = q.get()
            tmp = node.left
            node.left = node.right
            node.right = tmp
            if node.left:
                q.put(node.left)
            if node.right:
                q.put(node.right)
        return root

广度优先搜索先将头结点放入队列中，当队列不空时循环，每次计算队列长度，再内循环队列长度次，每个外循环循环每一层，内循环中对每层每个节点做相应的操作，出队列，然后交换左右节点，再将左右节点入队列。

/*
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) return;
        queue<TreeNode*> q;
        q.push(pRoot);
        while(!q.empty()){
            TreeNode* node = q.front();
            q.pop();
            TreeNode* cur = node->left;
            node->left = node->right;
            node->right = cur;
            if(node->left) q.push(node->left);
            if(node->right) q.push(node->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) return;
        auto rec = pRoot->left;
        pRoot->left = pRoot->right;
        pRoot->right = rec;
        Mirror(pRoot->left);
        Mirror(pRoot->right);
 
    }
};

先序遍历，每次交换当前节点的处的左右子节点，在递归的操作左右子节点。