Software Developer

This problem can be solved using hashing. The idea is to traverse the tree in an inorder fashion and insert every node’s value into a set. Also check if, for any node, the difference between the given sum and node’s value is found in the set, then the pair with the given sum exists in the tree.
Time Complexity : O(n).

This problem can be solved using two stacks.
Assume the two stacks are current : current level and next level. We would also need a variable to keep track of the current level order(whether it is left to right or right to left). We pop from the current level stack and print the nodes value. Whenever the current level order is from left to right, push the nodes left child, then its right child to the stack next level. 
Since a stack is a LIFO(Last-In-First_out) structure, next time when nodes are popped off nextlevel, it will be in the reverse order. On the other hand, when the current level order is from right to left, we would push the nodes right child first, then its left child. Finally, do-not forget to swap those two stacks at the end of each level(i.e., when current level is empty).

public class ThreadSeq 
{

	Object hello = new Object();
	Object world = new Object();

	public static void main(String[] args) throws InterruptedException 
	{
		for(int i=0; i<6;i++)
		{
			Runnable helloTask = new Runnable()
			{
				@Override
				public void run()
				{
					new ThreadSeq().printHello();
				}
			};

			Runnable worldTask = new Runnable()
			{
				@Override
				public void run()
				{
					new ThreadSeq().printWorld();
				}
			};

			Thread t1 = new Thread(helloTask);
			Thread t2 = new Thread(worldTask);
			t1.start();
			t1.join();
			t2.start();
			t2.join();
		}

	}

	public void printHello()
	{
		synchronized (hello) 
		{
			System.out.println("Hello");
		}
	}

	public void printWorld()
	{
		synchronized (world) 
		{
			System.out.println("World");
		}
	}
}

The recursive approach would be to traverse the tree T in preorder fashion. For every visited node in the traversal, see if the subtree rooted with this node is identical to S.
Time worst-case complexity is O(mn) where m and n are number of nodes in given two trees. 
Auxiliary space : O(n)

The above approach can be optimised to O(n) time complexity. The idea is based on the fact that inorder and preorder/postorder uniquely identify a binary tree. Tree S is a subtree of T if both inorder and preorder traversals of S arew substrings of inorder and preorder traversals of T respectively.
Steps : 
1) Find inorder and preorder traversals of T, store them in two auxiliary arrays inT[] and preT[].
2) Find inorder and preorder traversals of S, store them in two auxiliary arrays inS[] and preS[].
3) If inS[] is a subarray of inT[] and preS[] is a subarray preT[], then S is a subtree of T. Else not.

Tip 1 : The cross questioning can go intense some time, think before you speak.

Tip 2 : Be open minded and answer whatever you are thinking, in these rounds I feel it is important to have opinion.

Tip 3 : Context of questions can be switched, pay attention to the details. It is okay to ask questions in these round, like what are the projects currently the company is investing, which team you are mentoring. How all is the work environment etc.