## Monday, May 16, 2016

### Collection of Interview Questions

1. Given a binary search tree in which each node has a parent pointer, perform an inorder traversal without recursion, and without allocating any memory.
```class BSTNode {
BSTNode left, right, parent;
int value;
}
class BST {
BSTNode root;
void inorder_traversal() {
// what goes in here?
}
}```
For #1: if we have a successor(node) function we just start with the leftmost node, get its successor, its successor, … until done. The successor function: if the node has a right sub-tree, grab the leftmost node in it; otherwise find the first ancestor that we’re in the left sub-tree of — if there is no such ancestor then we’re at the rightmost node so there is no successor.
This should just be linear time on the whole.
2. Write a function that takes an array of ints, randomly chooses one of them to be the pivot, and rearranges the array so that all of the ints less than the pivot are to its left, and all of the ints greater than or equal are to its right. The function should return the index of the pivot. (yes, this is the “partition” step of quicksort)
3. Same as #2, but do it with two pivots. (this is more fun :)
4. Classical Min/Max Heaps are typically represented using arrays, since they’re complete trees. Imagine, though, that you’re using a Min-Heap represented using nodes. If you know the number of nodes already in the Min-Heap, write an algorithm to describe the path to the next open spot. For example, given the following Min-Heap:
```          5
/   \
8      10
/ \    /  \
12   9  13  20
/  \
18  15```
You can get to the next open spot by going left-right-left from the root (i.e., to the left of the 9). If you know that there are nine elements in the tree, you should be able to come up with this path deterministically, without resorting to searching the tree, doing BFS, etc. Write that algorithm. (N.B. I agonized over different approaches to this problem, then one of my colleagues walked into my office and trivially solved it in under 30 seconds)
For #4, if you convert the position you’re looking for into binary (i.e. position 9 becomes 1001) then reading from left to right after the initial 1 will give you the walk you need – 0 for left, 1 for right. So for example position 201 (binary 11001001) would be right, left, left, right, left, left, right.

Tristan's Collection of Interview Questions: Calculate log2() Using sqrt()
Problem: Calculate log2()  by only using sqrt().
https://baibingz.wordpress.com/2012/10/30/compute-log-using-sqrt/
log ab = log a + log b
log a = ln a / ln 2 = 1.4427 * ln a
ln 1+x = x when x is very small
Now combining those equations together and we have our solution.
For example, log 10 = 3.3219
Here is our computing flow, 10 = 1.25 * 2^3  // normalize the given number to [1, 2)
1.25 = 1.0000068098 ^ (2^15)  // sqrt until it reaches a small value
log 10 = log 1.25 * 2^3
= 3 + ln 1.25 / ln 2
= 3 + 1.4427 * 2^15 * ln 1.0000068098
= 3 + 1.4427 * 2^15 * 0.0000068098
= 3.3219
```public double log2WithSqrt (double x) {
if (x <= 0) return null;

double result_normalize = 0.0;
while (x < 1) {
x *= 2;
double++;
}
while (x >= 2) {
x /= 2;
double++;
}

double power_sqrt = 1.0;
while (x - 1.0 > 0.00001) {
x = Math.sqrt(x);
power_sqrt = power_sqrt * 2.0;
}

return result_normalize + 1.4427 * power_sqrt * (x - 1.0);
}```
http://yaozonggao.com/blog/?p=58
 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 double my_log2(double x) {   if(x == 0)       return -9999999;   if(x == 1)       return 0;   if(x < 1)       return -my_log2( 1 / x );      double val = 1;   while(x - 1 > 1e-6)   {     val = val * 2;     x = sqrt(x);   }      double ln2_val = 0.6931472;   return val * (x - 1) / ln2_val; }

Solution: The key here is you need to know log2(1+x) = x/ln2 = x/0.69 when x is very close to 1. Therefore the algorithm first use sqrt() to reduce x to be very close to 1 then we can use the formular.