【LeetCode每日一题】——剑指 Offer 27.二叉树的镜像

一【题目类别】

• 广度优先搜索

二【题目难度】

• 简单

三【题目编号】

• 剑指 Offer 27.二叉树的镜像

四【题目描述】

• 请完成一个函数，输入一个二叉树，该函数输出它的镜像。
• 例如输入：

     4
   /   \
  2     7
 / \   / \
1   3 6   9

• 镜像输出：

     4
   /   \
  7     2
 / \   / \
9   6 3   1

五【题目示例】

• 示例 1：
  • 输入：root = [4,2,7,1,3,6,9]
  • 输出：[4,7,2,9,6,3,1]

六【解题思路】

• 这个题目很经典，既可以用DFS做也可以用BFS做，但是本周既然是BFS的tag，所以使用BFS解决此问题
• 首先新建队列，头节点入队列
• 然后当队列不空时，取出队头元素，交换左右子树
• 交换完左右子树后，就完成了一步镜像交换
• 然后如果左右子树不为空，分别入队列
• 如此往复循环，直到队列为空
• 最后返回根节点即可

七【题目限制】

• 0 <= 节点个数 <= 1000

八【时间频度】

• 时间复杂度：$O(n)$，其中 $n$ 是二叉树的节点个数
• 空间复杂度：$O(n)$，其中 $n$ 是二叉树的节点个数

九【代码实现】

1. Java语言版

package BFS;

import java.util.LinkedList;
import java.util.Queue;

public class o27_ImageOfBinaryTree {

    int val;
    o27_ImageOfBinaryTree left;
    o27_ImageOfBinaryTree right;

    public o27_ImageOfBinaryTree(int val) {
        this.val = val;
    }

    public o27_ImageOfBinaryTree(int val, o27_ImageOfBinaryTree left, o27_ImageOfBinaryTree right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }

    public static void main(String[] args) {
        o27_ImageOfBinaryTree root = new o27_ImageOfBinaryTree(4);
        o27_ImageOfBinaryTree left = new o27_ImageOfBinaryTree(2);
        o27_ImageOfBinaryTree right = new o27_ImageOfBinaryTree(7);
        o27_ImageOfBinaryTree left1 = new o27_ImageOfBinaryTree(1);
        o27_ImageOfBinaryTree left2 = new o27_ImageOfBinaryTree(3);
        o27_ImageOfBinaryTree right1 = new o27_ImageOfBinaryTree(6);
        o27_ImageOfBinaryTree right2 = new o27_ImageOfBinaryTree(9);
        root.left = left;
        left.left = left1;
        left.right = left2;
        root.right = right;
        right.left = right1;
        right.right = right2;
        o27_ImageOfBinaryTree res = mirrorTree(root);
        preOrder(res);
    }

    public static void preOrder(o27_ImageOfBinaryTree root) {
        if (root != null) {
            System.out.print(root.val + " ");
            preOrder(root.left);
            preOrder((root.right));
        }
    }

    public static o27_ImageOfBinaryTree mirrorTree(o27_ImageOfBinaryTree root) {
        if (root == null) {
            return root;
        }
        Queue<o27_ImageOfBinaryTree> queue = new LinkedList<o27_ImageOfBinaryTree>();
        queue.offer(root);
        while (queue.size() != 0) {
            o27_ImageOfBinaryTree node = queue.poll();
            o27_ImageOfBinaryTree temp = node.left;
            node.left = node.right;
            node.right = temp;
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
        return root;
    }

}

2. C语言版

#include
#include

struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
};

struct TreeNode* mirrorTree(struct TreeNode* root)
{
	if (root == NULL)
	{
		return root;
	}
	struct TreeNode** queue = (struct TreeNode**)malloc(sizeof(struct TreeNode*) * 1001);
	int front = 0;
	int rear = 0;
	queue[rear++] = root;
	while (front != rear)
	{
		struct TreeNode* node = queue[front++];
		struct TreeNode* temp = node->left;
		node->left = node->right;
		node->right = temp;
		if (node->left != NULL)
		{
			queue[rear++] = node->left;
		}
		if (node->right != NULL)
		{
			queue[rear++] = node->right;
		}
	}
	return root;
}

/*主函数省略*/

十【提交结果】

1. Java语言版
   

2. C语言版