13

I have just finished a job interview and I was struggling with this question, which seems to me as a very hard question for giving on a 15 minutes interview.

The question was: Write a function, which given a stream of integers (unordered), builds a balanced search tree. Now, you can't wait for the input to end (it's a stream), so you need to balance the tree on the fly.

My first answer was to use a Red-Black tree, which of course does the job, but i have to assume they didn't expect me to implement a red black tree in 15 minutes.

So, is there any simple solution for this problem i'm not aware of?

Thanks,

Dave

templatetypedef
  • 362,284
  • 104
  • 897
  • 1,065
Dave
  • 131
  • 1
  • 3
  • Do you know anything about the integers (other than the fact that they're unsorted)? Are you allowed to build the BST in response to someone looking up an element, or must you have a BST available at all times? Can you build multiple different BSTs, or do you have to build just one? – templatetypedef Aug 29 '11 at 22:20
  • Well, maybe you could use a red black tree under a fairly liberal interpretation of the rules. Since 15 minutes is not a lot of time, if you are allowed to do something silly like use STL containers and algorithms, you could just create an std::map, then insert the objects directly into that (but I must admit that this is basically cheating). – Mikola Aug 29 '11 at 22:50
  • The question was as it appears, no other assumptions on the input or use. I just thought maybe there is a common algorithm for this and i am just not aware of it. Apparently they wanted me to implement a balanced tree as i know it. Good luck with that. – Dave Aug 30 '11 at 01:51
  • Does it has to be a BST? other sorted data structures are also valid? [Skip List](http://en.wikipedia.org/wiki/Skip_list) is much simpler [in my opinion] to implement then balanced BST – amit Aug 30 '11 at 06:44
  • I'm really bad at problems like that, but if the int-stream is randomized data and you know the min and max (MAX_INT?) creating a simple tree is automatically balanced if the root is MAX_INT/2? – Patrick B. Aug 30 '11 at 09:39
  • No. The input is a stream of numbers, which means it is of unknown length. Even if you could assume MAX_INT is in the stream (which you can't assume), you can't assume anything else on the integers stream. Lets say the stream contains as its first 3 integers MAX_INT/2, MAX_INT/2 + 1, MAX_INT/2 + 2.This input will result an unbalanced tree. – Dave Aug 30 '11 at 20:31

3 Answers3

10

I personally think that the best way to do this would be to go for a randomized binary search tree like a treap. This doesn't absolutely guarantee that the tree will be balanced, but with high probability the tree will have a good balance factor. A treap works by augmenting each element of the tree with a uniformly random number, then ensuring that the tree is a binary search tree with respect to the keys and a heap with respect to the uniform random values. Insertion into a treap is extremely easy:

  1. Pick a random number to assign to the newly-added element.
  2. Insert the element into the BST using standard BST insertion.
  3. While the newly-inserted element's key is greater than the key of its parent, perform a tree rotation to bring the new element above its parent.

That last step is the only really hard one, but if you had some time to work it out on a whiteboard I'm pretty sure that you could implement this on-the-fly in an interview.

Another option that might work would be to use a splay tree. It's another type of fast BST that can be implemented assuming you have a standard BST insert function and the ability to do tree rotations. Importantly, splay trees are extremely fast in practice, and it's known that they are (to within a constant factor) at least as good as any other static binary search tree.

Depending on what's meant by "search tree," you could also consider storing the integers in some structure optimized for lookup of integers. For example, you could use a bitwise trie to store the integers, which supports lookup in time proportional to the number of bits in a machine word. This can be implemented quite nicely using a recursive function to look over the bits, and doesn't require any sort of rotations. If you needed to blast out an implementation in fifteen minutes, and if the interviewer allows you to deviate from the standard binary search trees, then this might be a great solution.

Hope this helps!

templatetypedef
  • 362,284
  • 104
  • 897
  • 1,065
  • Well, first of all, it does help :) But i still think it is a big ask to do in an interview. The treap seems like a good solution, but i don't think this is what the interviewer meant. This is a really non-trivial solution to the BST problem, and if you are not familiar with it prior to the interview (like me ) than to come up with it is not really a realistic option. as to the splay tree, again, it is exactly as mentioning the red-black tree (although it is simpler to implement). But to implement it is still not trivial, and for a short interview it seems like a big ask. – Dave Aug 29 '11 at 21:53
  • I would second splay trees, though they aren't technically "balanced", they might be good enough for whatever the interview was asking (for example, look up the kth element or something like that). – Mikola Aug 29 '11 at 22:46
  • I don't think it's feasible to write a treap or a splay tree in 15 minutes. bitwise trie is a good one but don't know if the interviewer agrees :P. – Mu Qiao Aug 30 '11 at 02:18
  • @Mu Qiao- If all you need to support is insertion, then I think that you could code up a treap in 15 minutes. If you are comfortable implementing a basic BST insert, then you could probably get the basic insert code working in about 2 minutes, which gives you 13 minutes to work on the rotation logic. (Though I admit that 15 minutes for **any** interview question is pretty silly!) – templatetypedef Aug 30 '11 at 02:25
3

AA Trees are a bit simpler than Red-Black trees, but I couldn't implement one off the top of my head.

rmmh
  • 6,997
  • 26
  • 37
  • I think this is the best answer. If your going to commit a balanced tree algorithm to memory this is one of the simplest. This is a doubly good answer because the Delete for an AA-Tree is the most complex to implement and the question doesn't seem to require delete functionality. – Louis Ricci Aug 30 '11 at 14:43
1

One of the simplest balanced binary search tree is BB(α)-tree. You pick the constant α, which says how much unbalanced can the tree get. At all times, #descendants(child) <= (1-α) × #descendants(node) must hold. You treat it as normal binary search tree, but when the formula doesn't apply to some node anymore, you just rebuild that part of the tree from scratch, so that it is perfectly balanced.

The amortized time complexity for insertion or deletion is still O(log N), just as with other balanced binary trees.

svick
  • 236,525
  • 50
  • 385
  • 514