二叉树的镜像—输入输出处理

剑指 Offer 27. 二叉树的镜像
比较简单，可以采用递归也可以借助栈操作。

思路

在处理输入时，建立一个TreeNode类，并生成树，镜像之后比较层序遍历结果。

代码

class TreeNode{
    TreeNode left;
    TreeNode right;
    int val;
    public TreeNode(int val){this.val = val;}
}
public class Main0528 {
	 public static TreeNode mirrorTree(TreeNode root) {
        //递归 此函数的作用是返回以root为根节点的镜像树
        //对于左右子节点，递归调用此函数，再对结果进行交换
        if(root == null) return null;
        TreeNode l = mirrorTree(root.right);
        TreeNode r = mirrorTree(root.left);
        root.left = l;
        root.right = r;
        return root;
    }
    //层序遍历打印树
    public static void bfs(TreeNode root){
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            for(int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                System.out.print(node.val + " ");
                if(node.left != null){
                    queue.add(node.left);
                }
                if(node.right != null){
                    queue.add(node.right);
                }
            }
        }
    }
    public static TreeNode build(){
        TreeNode root = new TreeNode(4);
        TreeNode left = new TreeNode(2);
        TreeNode left1 = new TreeNode(1);
        TreeNode right1 = new TreeNode(3);
        TreeNode right = new TreeNode(7);
        TreeNode left2 = new TreeNode(6);
        TreeNode right2 = new TreeNode(9);
        root.left = left;
        root.right = right;
        left.left = left1;
        left.right = right1;
        right.left = left2;
        right.right = right2;
        return root;
    }
    public static void main(String[] args) {
        TreeNode root = build();
        bfs(root);
        mirrorTree(root);
        System.out.println();
        bfs(root);
    }
}