CareerCup

private static BinaryTreeNode convertToMirror(BinaryTreeNode root) {
		BinaryTreeNode temp;
		if (root != null) {
			convertToMirror(root.getLeft());
			convertToMirror(root.getRight());

			temp = root.getLeft();
			root.setLeft(root.getRight());
			root.setRight(temp);
		}
		return root;
	}

A simple recursive solution--

public static TreeNode Mirror(TreeNode root)
{
	if (!root) return null;

	TreeNode node = new TreeNode();
	node.data = root.data;
	node.left = Mirror(root.right);
	node.right = Mirror(root.left);

	return node;
}

void mirrorTree(TreeNode root){
//
if(root == null)
return;
mirrorTree(root._leftChild);
mirrorTree(root._rightChild);

if(root._leftChild!=null){
root._leftChild._rightChild = root;
root._leftChild = null;
}
if(root._rightChild!=null){
root._rightChild._leftChild = root;
root._rightChild = null;
}
}

Is it OK?

void mirrorCopy(Node *node){
	if(node == NULL) 
		return;
	mirrorCopy(node->m_pLeftChild);
	mirrorCopy(node->m_pRightChild);
	Node *pTemp;
	pTemp = node->m_pLeftChild;
	node->m_pLeftChild = node->m_pRightChild;
	node->m_pRightChild = pTemp;
}

public void createMirror(Node Root)
{
   if(Root == null)
   return;

   Node L = Root.Left;

   Node R= Root.Right;

   Root.Left=R;
   Root.Right=L;

   CreateMirror(Root.Left);
   CreateMirror(Root.Right);
}

you should swap in the post order fashion and not the preorder one.

public void mirror(Node originalTree, Node newTree)
{
if(originalTree== null)
return;

Node left = OriginalTree -> right;
Node right= OriginalTree -> left;

newTree = (Node) malloc (Node*sizeof(Node));
newTree->value = originalTree->value;
newTree->left = null;
newTree->right = null;

mirror(left, newTree -> left);
mirror(right, newTree -> right);
}

public TreeNode mirrorTree(TreeNode origTree)
{
if(NULL == origTree)
return NULL;

Node node = new TreeNode();
node->value = origTree->value;

node->left = mirrorTree(origTree->left);
node->right = mirrorTree(origTree->right);

return newTree;
}

public TreeNode mirrorTree(TreeNode origTree) 
{ 
	if(NULL == origTree) 
		return NULL; 

	Node node = new TreeNode();
	node->value = origTree->value;
	
	node->left = mirrorTree(origTree->left); 
	node->right = mirrorTree(origTree->right);

	return newTree; 
}

void TreeOperation::mirrorTree(TreeNode* node){
	if(node != NULL){
		mirrorTree(node->getLeftChild());
		mirrorTree(node->rightChild);
		swapChildren(node);
	}
}

void TreeOperation::swapChildren(TreeNode* parent){
	TreeNode* temp;
	temp=parent->getLeftChild();
	parent->setLeftChild(parent->rightChild);
	parent->rightChild = temp;
}

Please let me know If I am wrong

geekyjumps.blogspot.in/2013/09/create-mirror-of-binary-tree.html

geekyjumps.blogspot.in/2013/09/create-mirror-of-binary-tree.html

private TreeNode createMirror(TreeNode oldTree, TreeNode newTree){
    if(oldTree == null || newTree == null){return null;}
    newTree.left = oldTree.right;
    newTree.right = oldTree.left;
    createMirror(oldTree.left, newTree.right);
    createMirror(oldTree.right, newTree.left);
}

public TreeNode createMirror(TreeNode oldTree){
  if(oldTree == null){return null;}
  TreeNode newTree = oldTree;
  return createMirror(oldTree, newTree);
}