剑指offer系列16---二叉树的镜像

【题目】二叉树的镜像
【思路】方法一：采用递归方式进行交换，先交换根节点的左右节点，接着交换左右结点的左右结点
　　　　方法二：采用非递归方式，即依次遍历左右子树结点依次交换,采用栈操作方式stack

package com.exe4.offer;
import java.util.Stack;

/**
 * 16【题目】二叉树的镜像
 *    【思路】方法一：采用递归方式进行交换，先交换根节点的左右节点，接着交换左右结点的左右结点
 *             方法二：采用非递归方式，即依次遍历左右子树结点依次交换,采用栈操作方式stack
 * @author WGS
 *
 */
public class TreeMirror {
    //二叉树结点定义
    public static class TreeNode {
        int val = 0;
        TreeNode left = null;
        TreeNode right = null;

        public TreeNode(int val) {
            this.val = val;

        }

    }
    //采用递归方式进行交换，先交换根节点的左右节点，接着交换左右结点的左右结点
    public void mirrorExchange(TreeNode node){
        if(node==null || node.left==null || node.right==null){
            return;
        }
        //开始交换根节点的左右结点
        TreeNode tempNode=null;
        tempNode=node.left;
        node.left=node.right;
        node.right=tempNode;
        
        //继续交换
        if(node.left!=null)
            mirrorExchange(node.left);
        if(node.right!=null)
            mirrorExchange(node.right);
    }
    //采用非递归方式，即依次遍历左右子树结点依次交换,采用栈操作方式s
    public void mirrorExchange2(TreeNode root){
        if(root==null || root.left==null || root.right==null){
            return;
        }
         Stack<TreeNode> stack = new Stack<TreeNode>();
         stack.push(root);
         while(!stack.isEmpty()){
             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);
         }
    }

    //前序遍历1
    public void preInOreder(TreeNode T){
        if(T==null) return;
        System.out.println(T.val);
        preInOreder(T.left);
        preInOreder(T.right);
    }
     //前序遍历2
    public void preOrderTarverse(TreeNode root) {
        Stack<TreeNode> s = new Stack<TreeNode>();
        while (root != null || !s.isEmpty()) {
            //遍历左子树
            while (root != null) {
                System.out.println(root.val);
                s.push(root);
                root = root.left;
            }
            // 左子树遍历结束，继续遍历右子树
            if (!s.isEmpty()) {
                root = s.pop();
                root = root.right;
            }
        }
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(8);
        TreeNode node1 = new TreeNode(6);
        TreeNode node2 = new TreeNode(10);
        TreeNode node3 = new TreeNode(5);
        TreeNode node4 = new TreeNode(7);
        TreeNode node5 = new TreeNode(9);
        TreeNode node6 = new TreeNode(11);

        root.left = node1;
        root.right = node2;
        node1.left = node3;
        node1.right = node4;
        node2.left = node5;
        node2.right = node6;

        TreeMirror r = new TreeMirror();
        r.mirrorExchange2(root);

        r.preOrderTarverse(root);
    }
}