CareerCup

get a inorder traversal and either post order or pre order traversal.
Now start creating the new tree but in reverse order of traversals... your post order traversal will become preorder traversal and vice versa........

temp = T->left
T->left = T->right
T->right = temp

Recursively call the above method on T->left and T->right.

Tree* copyMirror(Tree* root)
{
if(!root) return null;
Tree* root1=(Tree*)malloc(sizeof(Tree));
root1->data=root->data;
root1->left=null;
root->right=null;
if(root->left)
root1->right=copyMirror(root->left);
if(root->right)
root1->left=copyMirror(root->right);

return root1;
}

void mirror(struct node *p)
{
struct node *temp1;
if(p != NULL){
mirror(p->left);
mirror(p->right);
temp1 = p->right;
p->right = p->left;
p->left = temp1;
}
}

Formated properly

void mirror(Node **root)
{
      if(*root==NULL) return;
       Node * temp = NULL;
       mirror(*root->left);
       mirror(*root->right);
       temp = *root->left;
       *root->left=*root->right;    	
      *root->right = temp;	

}

TreeNode Mirror(TreeNode root)
{
        if(NULL == root) return root;
      
       TreeNode temp = root->left;
       root->left= Mirror(root->right);
       root->right = Mirror(temp);
       return root;
}

struct node {
   int value;
   struct node* left;
   struct node* right;
};
typedef struct node* NODE;

NODE CopyTree (NODE root) {
  if (root == NULL)
    return NULL;
  NODE subroot = GetNode();
  subroot->value = root.value;
  subroot->left = CopyTree (root->left);
  subroot->right = CopyTree (root->right);
  
  return subroot;
}