Leena AI Software Development Engineer Interview Questions, Process, and Tips

Binary search has O(log n) time complexity for arrays and O(n) for linked lists.

• Binary search is efficient for arrays due to their random access nature.

• Linked lists require sequential traversal, making binary search inefficient.

• For arrays, the time complexity is O(log n) as the search space is halved with each iteration.

• For linked lists, the time complexity is O(n) as all nodes must be visited to find the target.

• Binary...read more

Construct a tree using inorder and postorder traversal lists.

• The last element of the postorder list is the root of the tree.

• Find the root in the inorder list and split the list into left and right subtrees.

• Recursively construct the left and right subtrees using the corresponding sublists.

• Return the root node.

• Time complexity: O(n^2) in worst case, O(nlogn) on average.

Find depth of binary tree through recursion and iteration

• Recursively traverse left and right subtrees and return the maximum depth

• Iteratively traverse the tree using a stack or queue and keep track of the depth

• Depth of an empty tree is 0

• Depth of a tree with only one node is 1

Intersection of two arrays is the common elements present in both arrays.

• Sort both arrays and use two pointers to compare elements.

• Use a hash set to store elements of one array and check for presence in the other array.

• If arrays are already sorted, use binary search to find common elements.

Find the heavier ball from 8 identical balls using a balance weighting machine in least number of tries.

• Divide the balls into 3 groups of 3, 3, and 2 balls.

• Weigh the first two groups against each other.

• If they balance, the heavier ball is in the remaining group of 2 balls.

• If one group is heavier, weigh two balls from that group against each other.

• If they balance, the heavier ball is the remaining ball.

• If one ball is he