Software Developer

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. Steps :
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.

The naive approach would be to use an auxiliary array. Copy all elements to that array. Copy all negative elements first to the original array and then all positive elements. This approach would have a time complexity of O(N) but also uses O(N) auxiliary space. 
For constant space, we first count total negative numbers. 
Then till all negative numbers are moved to the beginning, traverse the array. Swap the positions of negative and positive elements and move negative numbers one by one to correct position.

The question can be solved recursively in O(N) time complexity and O(N) auxiliary space complexity. 
Store the initial value of the node in a variable. 
Next, Recursively call for left and right subtrees and change the value of the current node as sum of the values returned by the two recursive calls.
At last, return the sum of new value and the initial value.

String Pool in java is a pool of Strings stored in Java Heap Memory. String pool helps in saving a lot of space for Java Runtime although it takes more time to create the String. String Pool is possible only because String is immutable in Java and its implementation of String interning concept. String pool is also an example of Flyweight design pattern.

Singleton is a creational design pattern which ensures that a class has only one instance, while providing a global access point to this instance.
The Observer Pattern defines a one to many dependency between objects so that one object changes state, all of its dependents are notified and updated automatically.

HashMap is a non-synchronized collection class. So, we need to explicitly synchronise them. HashMap can be synchronized using the Collections.synchronizedMap() method. It returns a thread-safe map backed up by the specified HashMap. In order to guarantee serial access, it is critical that all access to the backing map is accomplished through the returned map.
Syntax: public static Map synchronizedMap(Map m)
Parameters: This method takes the map as a parameter to be “wrapped” in a synchronized map.
Return Value: This method returns a synchronized view of the specified map.

A process is an instance of a program that is being executed. Thread is a lightweight process that is managed by the scheduler independently. For Eg : Opening a new browser is a process while opening multiple tabs in a browser is thread. 
Processes are independent of each other while threads are interdependent and share memory.
Each process is treated as a new process by the operating system while with threads. the OS takes all the user-level threads as a single process.
If one process gets blocked by the operating system, then the other process can continue the execution. But if any user-level thread gets blocked, all of its peer threads also get blocked because OS takes all of them as a single process.