The mirror image of the binary tree (array, traverse back and forth to rebuild the binary tree)

Topic description

Operates the given binary tree, transforming it into a mirror image of the source binary tree.

Enter description:

Mirror Definition of Binary Tree: Source Binary Tree
    	    8
    	   /  \
    	  6   10
    	 / \  / \

	5  7 9 11
    	mirror binary tree
    	    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);
        }
    }
};

intmain ()
{
    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;
}