二叉树的镜像（数组，前后 遍历重建二叉树）

题目描述

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

输入描述:

二叉树的镜像定义：源二叉树 
    	    8
    	   /  \
    	  6   10
    	 / \  / \

	5  7 9 11
    	镜像二叉树
    	    8
    	   /  \
    	  10   6
    	 / \  / \
    	11 9 7  5

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

struct TreeNode
{
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x):val(x),left(NULL),right(NULL){}
};

class Solution
{
public:
    void Mirror(TreeNode *pRoot)
    {
        if(pRoot==NULL)
           return ;
         TreeNode *tmpNode;
         if(pRoot->left||pRoot->right)
         {
             tmpNode=pRoot->left;
             pRoot->left=pRoot->right;
             pRoot->right=tmpNode;
             if(pRoot->left)
             {
                 Mirror(pRoot->left);
             }
             if(pRoot->right)
             {
                 Mirror(pRoot->right);
             }
         }
    }
    TreeNode* ConstructT(int *preorder,int *inorder,int len)
    {
        TreeNode* pRoot = (TreeNode*)malloc(sizeof(TreeNode));
        int index =0;
        while(inorder[index]!=preorder[0]&&index<len)
        {
            index++;
        }
        if(index==len)
        {
            return NULL;
        }
        pRoot->val=preorder[0];
        pRoot->left=ConstructT(preorder+1,inorder,index);
        pRoot->right=ConstructT(preorder+index+1,inorder+index+1,len-index);
        return pRoot;
    }
    void PrintPreorder(TreeNode *pRoot)
    {
        if(pRoot)
        {
            cout<<pRoot->val;
            PrintPreorder(pRoot->left);
            PrintPreorder(pRoot->right);
        }
    }
};

int main()
{
    Solution s;
    TreeNode* pRoot;
    int preorder[]={8,6,5,7,10,9,11};
    int inorder[]={5,6,7,8,9,10,11};
    int len=7;
    pRoot=s.ConstructT(preorder,inorder,len);
    s.PrintPreorder(pRoot);
    s.Mirrior(pRoot);
    s.PrintPreorder(pRoot);
    return 0;
}