CareerCup

Do you mean to find the mirror ? If that, then you can exchange the left with the right ptr and recurse down both the subtrees.

Following is the recursive solution to the problem...

node *mirror(node *root)
{
  node *temp;
  
  if(root == NULL) 
	return NULL;
   
  temp = (node *)malloc(sizeof(node));

  temp->data  = root->data;
  temp->left  = mirror(root->right);
  temp->right = mirror(root->left);

  return temp;
}

a
b c
d e f g is the input

the output should be
d e f g
b c
a

this is what it means by reversing a binary tree

it should not mean that u r simply printing it in levelorder ok
u need to adjust the links
so the code is required to adjust the links recursively!!

in that case chk this out...
http://www.careercup.com/question?id=60068

it has be a mirror only,,,else the Qs is wrong.
btw, the simplest/easiest solution is just to keep rotating the left & right pointers at each step of forming the new tree...thats it...look at the link in Samwise's reply...

Here is my code in C#.
A list is used to store the leaf node (which finally becomes roots).
Based on Post-Order traversal and it works.
May be you can add code to make initial root.left = root.right = null.
I tested and it works :)

public List<node> list = null;
public void Reverse()
{
list = new List<node>();
ReverseTree(root, null);
}

private void ReverseTree(node rootptr,node rootroot)
{
node temp;
if (rootptr.left != null)
{
ReverseTree(rootptr.left,rootptr);
}

if (rootptr.right != null)
{
ReverseTree(rootptr.right,rootptr);
}

if ((rootptr.left == null) && (rootptr.right == null))
{
list.Add(rootptr);
}

if (rootroot != null)
rootptr.left = rootroot;
}

struct node* mirror(struct node*T , struct node*T2)
{
if(T==NULL)return NULL;

T2->data=T->data;

if(T->left!=NULL)
T2->right=mirror(T->left);

if(T->right!=NULL)
T2->left=mirror(T->right);

return T2;

}

def reverse(t):
    if "L" not in t and "R" not in t:
        return t
    t["L"], t["R"] = reverse(t["R"]), reverse(t["L"])
    return t