剑指offer：二叉树镜像

题目描述

操作给定的二叉树，将其变换为源二叉树的镜像。

输入描述:

二叉树的镜像定义：源二叉树 
    	    8
    	   /  \
    	  6   10
    	 / \  / \
    	5  7 9 11
    	镜像二叉树
    	    8
    	   /  \
    	  10   6
    	 / \  / \
    	11 9 7  5

交换流程：

 

                     

                图①                                                            图②                                                                图③ 

从根节点开始，先交换根节点的左右子节点，此时对于左右子节点来说，他们如果还存在子节点，那么这些节点是还没有做交换的。如图1，对根节点8的左右子节点交换，只是交换了6和10，而6,10对应的子节点保持不变。

接下来，对根节点的左节点，将其视为一颗新的二叉树，交换它的左右子节点。

同样的，对根节点的右节点，将其视为一颗新的二叉树，交换它的左右子节点。

总结上面的几个步骤：我们先先序遍历这个树的子结点，如果子结点有子结点，那么就交换，当交换完成所有的非叶子结点，那么就是我们所要求的镜像。

递归的方法：

package com.day01;
import  java.util.Stack;

class MirrorDemo {
	//对二叉树的遍历，一般都采用递归的方法
	 public void Mirror(TreeNode root) {
		 if(root==null||(root.left==null&&root.right==null)){
			 return;
		 }
		 //根节点下存在左右子节点，交换左右子节点
		 TreeNode temp=root.left;
		 root.left=root.right;
		 root.right=temp;
		 
		 if(root.left!=null){
			 //左子树不为空，递归调整左子树
			 Mirror(root.left);
		 }
		 if(root.right!=null){
			 //右子树不空，递归调整右子树为镜像
			 Mirror(root.right);
		 }
	        
	    }
	 
	 //为了测试，写一个方法为树设置左右子节点
	 private static void setSubTreeNode(TreeNode root,TreeNode lchild,TreeNode rchild) {
			// TODO Auto-generated method stub
			if(root==null){
				return;
			}
			root.left=lchild;
			root.right=rchild;	
		}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//测试代码
		TreeNode node1=new TreeNode(8);
		TreeNode node2=new TreeNode(6);
		TreeNode node3=new TreeNode(10);
		TreeNode node4=new TreeNode(5);
		TreeNode node5=new TreeNode(7);
		TreeNode node6=new TreeNode(9);
		TreeNode node7=new TreeNode(11);
		TreeNode node8=new TreeNode(4);
		TreeNode node9=new TreeNode(5);
		
		setSubTreeNode(node1,node2,node3);
		setSubTreeNode(node2, node4, node5);
		setSubTreeNode(node3, node6, node7);
		setSubTreeNode(node5,node8,null);
		setSubTreeNode(node6,null,node9);
		
		MirrorDemo md=new MirrorDemo();
		md.Mirror2(node1);
		System.out.println(node1);
		

	}

	

}

循环的方法：

所有用递归解决的问题，都能借助外部空间，栈，来用循环解决。

import java.util.Stack;
public class Solution {
    public void Mirror(TreeNode root) {
        if(root==null){
             return;
         }
         Stack<TreeNode> stack=new Stack<>();
         stack.push(root);
         while(stack.size()>0){
             TreeNode node=stack.pop();
             TreeNode temp=node.left;
             node.left=node.right;
             node.right=temp;
              
             if(node.left!=null){
                 stack.push(node.left);
             }
             if(node.right!=null){
                 stack.push(node.right);
             }
         }
               
    }
}

参考：https://www.cnblogs.com/csbdong/p/5701070.html