Software Engineer

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.

Factorial can be calculated using following recursive formula: 
n! = n * (n-1)!
n! = 1 if n = 0 or n = 1
Factorial can also be calculated iteratively as recursion can be costly for large numbers. 
Factorial(n)
{
Initialise a variable res = 1
for (i = 2 to i <= n) do :
res = res* i
return res
}

A page in a paging system is a virtual memory block with a fixed length. But a frame in a paging system is a main memory block with fixed length.
A page has virtual address and it is transferred as a unit between main memory and secondary memory. But a frame can only hold one page of virtual memory.
Programs and data are stored on disk which is divided into fixed sized blocks. They are called pages. These blocks are used as virtual memory. Main memory on the other hand is divided into fixed sized blocks such that the size is equal to the size of a page.
A page address is a virtual address that refers to the address on secondary memory. But a frame address is an address of physical location on main memory.

A queue can be used to do level order traversal of the tree. For each node, first visit the node and then push its children nodes in the FIFO queue. 
printLevelorder(tree)

1) Create an empty queue q
2) temp_node = root /*start from root*/
3) Loop while temp_node is not NULL
a) print temp_node->data.
b) Enqueue temp_node’s children 
(first left then right children) to q
c) Dequeue a node from q.

Time Complexity : O(n) where n is the number of nodes in the binary tree 
Space Complexity : O(n) where n is the number of nodes in the binary tree

Mutex uses a locking mechanism i.e. if a process wants to use a resource then it locks the resource, uses it and then release it. But on the other hand, semaphore uses a signaling mechanism where wait() and signal() methods are used to show if a process is releasing a resource or taking a resource.
A mutex is an object but semaphore is an integer variable.
In semaphore, we have wait() and signal() functions. But in mutex, there is no such function.
A mutex object allows multiple process threads to access a single shared resource but only one at a time. On the other hand, semaphore allows multiple process threads to access the finite instance of the resource until available.
In mutex, the lock can be acquired and released by the same process at a time. But the value of the semaphore variable can be modified by any process that needs some resource but only one process can change the value at a time.

Sizeof is a compile time unary operator which can be used to compute the size of its operand. The result of sizeof is of unsigned integral type which is usually denoted by size_t. sizeof can be applied to any data-type, including primitive types such as integer and floating-point types, pointer types, or compound datatypes such as Structure, union etc.