剑指 Offer 27. 二叉树的镜像

package SwordOffer;

import java.util.Stack;

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

例如输入：

     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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/er-cha-shu-de-jing-xiang-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
* @Param:
* @return:
* @Author: lvhong
* @Date:
* @E-mail lvhong282@163.com
*/
public class lab27easy {

       class TreeNode {
          int val;
          TreeNode left;
          TreeNode right;
          TreeNode(int x) { val = x; }
      }
        //递归   前序遍历
        // public TreeNode mirrorTree(TreeNode root) {
        //     if(root==null)  {
        //         return null;
        //     }
        //     TreeNode temp = root.left;
        //     root.left=mirrorTree(root.right);
        //     root.right=mirrorTree(temp);
        //     return root;
        // }

        //递归  中序遍历
// public TreeNode mirrorTree(TreeNode root) {
//     if (root == null)
//         return null;
//     mirrorTree(root.left);
//     //子节点交换
//     TreeNode temp = root.left;
//     root.left = root.right;
//     root.right = temp;
//     //上面交换过了，这里root.right要变成root.left
//     mirrorTree(root.left);
//     return root;
//  }

        //递归  后序遍历
//  public TreeNode mirrorTree(TreeNode root) {
//     if (root == null)
//         return null;
//     TreeNode left = mirrorTree(root.left);
//     TreeNode right = mirrorTree(root.right);
//     root.left = right;
//     root.right = left;
//     return root;
// }

        //非递归  中序遍历
        public static TreeNode mirrorTree(TreeNode root) {
            //如果为空直接返回
            if (root == null)
                return null;
            Stack<TreeNode> stack = new Stack<>();
            TreeNode node = root;
            while (node != null || !stack.isEmpty()) {
                while (node != null) {
                    stack.push(node);
                    node = node.left;
                }
                if (!stack.isEmpty()) {
                    node = stack.pop();
                    //子节点交换
                    TreeNode temp = node.left;
                    node.left = node.right;
                    node.right = temp;
                    //注意这里以前是node.right，因为上面已经交换了
                    //，所以这里要改为node.left
                    node = node.left;
                }
            }
            return root;
        }


        //借用栈深度优先遍历
        // public TreeNode mirrorTree(TreeNode root) {
        //     if(root==null){
        //         return null;
        //     }
        //     Stack<TreeNode> stack = new Stack<>(){
        //         {add(root);}
        //         };
        //     while(!stack.isEmpty()){
        //         TreeNode node=stack.pop();
        //         if(node.left!=null)  stack.push(node.left);
        //         if(node.right!=null) stack.push(node.right);
        //         TreeNode temp =node.left;
        //         node.left=node.right;
        //         node.right=temp;
        //     }
        //     return root;
        // }


        //借用队列广度优先遍历
        //  public TreeNode mirrorTree(TreeNode root) {
        //     if(root==null){
        //         return null;
        //     }
        //     Queue<TreeNode> queue = new LinkedList<>(){{add(root);}};
        //     while(!queue.isEmpty()){
        //         TreeNode node = queue.poll();
        //         if(node.left!=null) queue.add(node.left);
        //         if(node.right!=null) queue.add(node.right);
        //         TreeNode temp = node.left;
        //         node.left=node.right;
        //         node.right=temp;
        //     }
        //     return root;
        //  }
}