链接

https://leetcode-cn.com/problems/er-cha-shu-de-jing-xiang-lcof/
难度： #简单

题目

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

例如输入：

     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]

限制：
0 <= 节点个数 <= 1000

注意：本题与主站 226 题相同：https://leetcode-cn.com/problems/invert-binary-tree/

代码框架

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode mirrorTree(TreeNode root) {

    }
}

题目解析

解答思路1：
递归解法，
先序遍历二叉树，
交换其左右节点，
然后递归处理左右节点，
使其子节点也左右交换。

解答思路2：
迭代解法，
按层遍历，
使用辅助队列，
交换每一个节点的左右节点即可，
然后把不为空的左右节点加入队列。

测试用例

package edu.yuwen.sowrd.num27.solution;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import edu.yuwen.sowrd.entity.TreeNode;
import edu.yuwen.sowrd.num27.sol2.Solution;

public class SolutionTest {

    /**
     * 例如输入：
         4
       /   \
      2     7
     / \   / \
    1   3 6   9
               镜像输出：
         4
       /   \
      7     2
     / \   / \
    9   6 3   1
     */
    @Test
    public void testCase1() {
        Solution solution = new Solution();
        TreeNode node1 = new TreeNode(4);
        TreeNode node2 = new TreeNode(2);
        TreeNode node3 = new TreeNode(7);
        TreeNode node4 = new TreeNode(1);
        TreeNode node5 = new TreeNode(3);
        TreeNode node6 = new TreeNode(6);
        TreeNode node7 = new TreeNode(9);

        node1.left = node2;
        node1.right = node3;

        node2.left = node4;
        node2.right = node5;

        node3.left = node6;
        node3.right = node7;

        TreeNode root = node1;
        TreeNode mirrorNode = solution.mirrorTree(root);

        node1 = mirrorNode;
        node2 = node1.left;
        node3 = node1.right;
        node4 = node2.left;
        node5 = node2.right;
        node6 = node3.left;
        node7 = node3.right;
        Assertions.assertEquals(4, node1.val);
        Assertions.assertEquals(7, node2.val);
        Assertions.assertEquals(2, node3.val);
        Assertions.assertEquals(9, node4.val);
        Assertions.assertEquals(6, node5.val);
        Assertions.assertEquals(3, node6.val);
        Assertions.assertEquals(1, node7.val);
    }

}

解答1 推荐

package edu.yuwen.sowrd.num27.sol1;

import edu.yuwen.sowrd.entity.TreeNode;

public class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        if (root == null) {
            return null;
        }

        recurve(root);

        return root;
    }

    /**
     * 交换当前节点的左右节点
     */
    private void recurve(TreeNode node) {
        TreeNode temp = node.left;
        node.left = node.right;
        node.right = temp;

        if (node.left != null) {
            recurve(node.left);
        }

        if (node.right != null) {
            recurve(node.right);
        }
    }
}

解答2 推荐

package edu.yuwen.sowrd.num27.sol2;

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

import edu.yuwen.sowrd.entity.TreeNode;

public class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        if (root == null) {
            return null;
        }

        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root);

        while (!q.isEmpty()) {
            TreeNode node = q.poll();
            // 交换左右节点
            TreeNode temp = node.left;
            node.left = node.right;
            node.right = temp;

            // 不为空的节点加入队列
            if (node.left != null) {
                q.offer(node.left);
            }
            if (node.right != null) {
                q.offer(node.right);
            }
        }

        return root;
    }
}