CareerCup

NODE* reverse(NODE* current)
{
    if(current == NULL)return NULL;
    
    NODE* left = reverse(current->lchild);
    NODE* right = reverse(current->rchild);
    
    if(left != NULL)
    {
         left->lchild = current;
         left->rchild = NULL;
    }
    
    if(right != NULL)
    {
         right->lchild = current;
         right->rchild = NULL;
    }
    
    return current; 
}

Small mistake in base condition root's child's pointers shd be to next.

Here is a code ....see if it is correct
void reverseTree(node*root , node* next){
if(root!=NULL){
reverseTree(root->left,root);
reverseTree(root->right,root);
root->left=next;
root->right=next;
}
}

Initial call will be reverseTree(root,NULL)

I use only one parameter, instead of two. see if it is correct.

void reverseTree(node*root){
if(root!=NULL){
reverseTree(root->left);
reverseTree(root->right);
root->left->left=root;
root->left->right=root;
root->right->right=root;
root->right->left=root;
}
}

Initial call will be reverseTree(root).

Modify post-order traversal. Instead of printing the node reverse the pointers:

I answered the same but faltered in the code....

code above wud crash for leaf nodes atleast.

Most of the above solutions are wrong.
Correct solution is below.

void ReverseNodePointers(Node* node, Node* parent)
{
    if(node == null) return;
    Node* leftNode = node->left; // temp child pointer since the node's pointer will be changed.
    Node* rightNode = node->right; // temp child pointer since the node's pointer will be changed.
    node->left = parent;
    node->right = parent;
    traverse(leftNode, node);
    traverse(rightNode, node);
}

ReverseNodePointers(head, head);

C code:

struct tree {
   struct tree* left;
   struct tree* right;
   void*        data;
};

void reverseTree(struct tree* parent, struct tree* node) {
   if(node) {
      reverseTree(node, node->left);
      reverseTree(node, node->right);
      if(parent) {
         if(node == parent->left) {
            node->right = parent;
            parent->left = 0;
         }
         else {
            node->left = parent;
            parent->right = 0;
         }
      }
   } 
}

it should be similar with reversing a singly linked list
Below is the code

listnode *reverseLL(listnode *root) {
    if (!root || !(root->next))
        return root;
    else {
        listnode *tmp = reverseLL(root->next);
        root->next->next = root;
        root->next = NULL;
        return tmp;
    }
}
treenode *reverseBT(treenode *root) {
    if (!root || 
        (root->left == NULL
         && root->right == NULL)) {
        return root;
    } else {
         if (root->left) {
             reverseBT(root->left);
             root->left->left = root;
             root->left->right = root;
             root->left = NULL;
         }
         if (root->right) {
             reverseBT(tmp->right);
             root->right->left = root;
             root->right->right = root;
             root->right = NULL;
         }
    }
}

All the approaches one way or the other doing the same thing. But at the end we are left with root node with both of its pointers null thus losing ability to reach any other node in the entire tree. Is this what is expected?

The Question is in correct.
Considering a binary Tree.
Parent can have 0 - 2 child nodes
child can have 0 - 1 parent ( 0 in case of root )
How do you reverse this ?

Here is a code ....see if it is correct
void reverseTree(node*root , node* next){
if(root!=NULL){
reverseTree(root->left,root);
reverseTree(root->right,root);
root->left=root;
root->right=root;
}
}

Initial call will be reverseTree(root,NULL)