剑指 Offer 27. 二叉树的镜像

剑指 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]

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

---

思路1：递归

首先想到的是递归
如果root.left已经完成镜像，root.right也已经完成镜像，那么再将root.left本身的节点与root.right本身的节点做交换，则镜像完成

/**
 * 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) {
        //第一步：边界条件
        if (root == null) return root;

        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;

        mirrorTree(root.left);
        mirrorTree(root.right);

        return root;
    }
}

仔细想想，这不就是前序遍历的递归形式吗？

class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        //第一步：边界条件
        if (root == null) return root;
        
        System.out.print(root.val);

		if (root.left != null) {
			 mirrorTree(root.left);
		}
        
        if (root.right != null) {
			mirrorTree(root.right);
		}
        return root;
    }
}

思路2：非递归 - 层序遍历 - 队列

数据结构与算法—树---翻转二叉树、二叉树的高度

思路3： 非递归 - 前序遍历 - 栈

/**
 * 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) {
        //第一步：边界条件
        if (root == null) return root;
        
        //建立一个空栈
        Stack<TreeNode> stack = new Stack<TreeNode>();

        //入栈
        stack.push(root);

        while(!stack.isEmpty()){
            TreeNode top = stack.pop();
            //不能去掉，去掉的话，如果top为null，那么top.left就是null.top❌
            if (top == null) continue;
            
            //此处是top，而不是root需要注意⚠️
            TreeNode temp = top.left;
            top.left = top.right;
            top.right = temp;

            if (top.right != null) stack.push(top.right);
            if (top.left != null) stack.push(top.left);
        }
        return root;
    }
}

又学到一种前序遍历，利用栈的写法