Software Engineer

To reverse a number following steps should be performed:
Take the number’s modulo by 10
Multiply the reverse number by 10 and add modulo value into the reverse number.
Divide the number by 10.
Repeat above steps until number becomes zero.

Pseudocode :
reverse(n){

rev = 0; // reversed number
rem; // initialise a variable to store remainder

while(n>0){
rem = n%10;
rev = (rev*10) + rem;
n = n/10;
}
return rev;
}

This can be solved both: recursively and iteratively.
The recursive approach is more intuitive. First reverse all the nodes after head. Then we need to set head to be the final node in the reversed list. We simply set its next node in the original list (head -> next) to point to it and sets its next to NULL. The recursive approach has a O(N) time complexity and auxiliary space complexity.
For solving the question is constant auxiliary space, iterative approach can be used. We maintain 3 pointers, current, next and previous, abbreviated as cur, n and prev respectively. All the events occur in a chain.
1. Assign prev=NULL, cur=head .
2. Next, repeat the below steps until no node is left to reverse:
1. Initialize n to be the node after cur. i.e. (n=cur->next)
2. Then make cur->next point to prev (next node pointer).
3. Then make prev now point to the cur node.
4. At last move cur also one node ahead to n.
The prev pointer will be the last non null node and hence the answer.

First, new int[5] must be freed using delete[], and malloc(...) must be freed using free. You cannot mix and match.
Second, if you use a type with a constructor then malloc will not call the constructor, and free will not call the destructor. You have to call them manually (or just use new/free).