【剑指offer】二叉树的镜像

题目描述

操作给定的二叉树，将其变换为源二叉树的镜像。 
输入描述:

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

仔细观察原二叉树与镜像二叉树，可以发现镜像二叉树实际上就是把每个节点的左右孩子结点进行了交换，比如在遍历到8这个节点时候，首先交换其左右孩子6和10，其对应的子树也应该进行交换。所以我们可以采用前序遍历的方法进行操作，每当遇到一个结点的时候，首先判断其是否有左右孩子（有其中之一即可），如果有的话，就交换其左右孩子，然后继续遍历其左右子树，只要不为空就继续交换其左右孩子节点（在交换具有孩子结点的结点的时候，其孩子结点也一并被交换了）。

package com.gpl.offer.jianzhi;

import java.util.Stack;

/**
 * Created by gpl on 2016/8/11.
 */
public class MirrorTree {
    public static class Node{   //树的子结构
        int val;
        Node left;
        Node right;
        public void setLeft(Node left) {
            this.left = left;
        }

        public void setRight(Node right) {
            this.right = right;
        }

        public Node(int val){
            this.val = val;
        }
    }

    public void mirrorTree(Node root){    //递归
        if(root == null ||(root.left ==null && root.right == null))
            return;
        Node temp = root.left;
        root.left = root.right;
        root.right = temp;
        if(root.left !=null){
            mirrorTree(root.left);
        }
        if(root.right != null){
            mirrorTree(root.right);
        }

    }

    public void mirrorTree1(Node root){    //非递归
        if(root == null ||(root.left ==null && root.right == null))
            return;
        Stack<Node> s = new Stack<Node>();
        s.push(root);
        while(!s.isEmpty()){
            Node node = s.pop();
            Node temp = node.left;
            node.left = node.right;
            node.right = temp;
            if(node.left!=null)
                s.push(node.left);
            if(node.right!=null)
                s.push(node.right);
        }
    }


    public void preOrder(Node root){  //前序遍历非递归
        if(root == null || (root.left == null && root.right == null))
            return;
        Stack<Node> stack = new Stack<Node>();
        stack.push(root);
        Node node  = root;
        while(!stack.isEmpty()){
            while(node!=null){
                System.out.println(node.val);
                stack.push(node);
                node = node.left;
            }
            if(!stack.isEmpty()){
                node = stack.pop();
                node = node.right;
            }
        }
    }

    public void InOrder(Node root){
        if(root == null || (root.left == null && root.right == null))
            return;
        Stack<Node> stack = new Stack<Node>();
//        stack.push(root);
        Node node = root;
        while(!stack.isEmpty() || node != null){
            while(node!=null){
                stack.push(node);
                node = node.left;
            }
            if(!stack.isEmpty()){
                node = stack.peek();
                System.out.println(node.val);
                stack.pop();
                node = node.right;
            }
        }
    }

    public void pre(Node root){     //前序遍历递归
        if(root != null){
            System.out.println(root.val);
            pre(root.left);
            pre(root.right);
        }
    }

    public static void main(String args[]) {
        MirrorTree mt = new MirrorTree();
        Node root1 = new Node(1);
        Node node1 = new Node(11);
        Node node2 = new Node(21);
        root1.setLeft(node1);
        root1.setRight(node2);
        Node node3 = new Node(31);
        Node node4 = new Node(32);
        node1.setLeft(node3);
        node2.setLeft(node4);
        mt.mirrorTree1(root1);
        mt.preOrder(root1);

    }

}