参考自：《剑指Offer——名企面试官精讲典型编程题》

题目：二叉树的镜像
请完成一个函数，输入一个二叉树，该函数输出它的镜像（左右子节点交换）。
例如：

//            10
//         /      \
//        6        14
//       /\        /\
//      4  8     12  16

镜像为：

//            10
//         /      \
//       14        6
//       /\        /\
//      16 12     8  4

主要思路：二叉树的镜像可以想象成以父节点为中心，交换左右子节点位置。因此，需要递归交换每个节点的左右子节点。

关键点：递归，二叉树镜像的定义

时间复杂度：O(n)

public class MirrorTree
{
    public static void main(String[] args)
    {
//            10
//         /      \
//        6        14
//       /\        /\
//      4  8     12  16
        TreeNode root = TreeNode.generateBinaryTree();
        mirrorNode(root);        
    }

    private static TreeNode mirrorNode(TreeNode root)
    {
        if (root == null) return null;
        TreeNode leftNode = root.left;
        TreeNode rightNode = root.right;
        //递归交换左右子节点
        root.left = mirrorNode(rightNode);
        root.right = mirrorNode(leftNode);
        return root;
    }
}

public class TreeNode
{
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x)
    {
        val = x;
    }

//            10
//         /      \
//        6        14
//       /\        /\
//      4  8     12  16
    /**
     * 生成二叉搜索树
     * @return
     */
    public static TreeNode generateBinaryTree()
    {
        TreeNode root = new TreeNode(10);
        TreeNode node6 = new TreeNode(6);
        TreeNode node14 = new TreeNode(14);
        TreeNode node4 = new TreeNode(4);
        TreeNode node8 = new TreeNode(8);
        TreeNode node12 = new TreeNode(12);
        TreeNode node16 = new TreeNode(16);
        connectNode(root, node6, node14);
        connectNode(node6, node4, node8);
        connectNode(node14, node12, node16);
        return root;
    }

    private static void connectNode(TreeNode root, TreeNode left, TreeNode right)
    {
        root.left = left;
        root.right = right;
    }
}