A modified van Emde Boas data structure that achieves time complexity for successor/predecessor/insert/search/delete in `O(lg w)`

(with high probability), where `w`

is the bits of the word used to store the integer. Space complexity is `O(n)`

, where `n`

is how many numbers are stored. Thus, the constrain is that `lg n <= w`

, since any number must fit in a word.

If `w`

is not too high, then this is optimal. In case `w`

is too high, fusion trees are the best. However, dynamic versions of fusion tree only achieve expected `O(lg n/lg w)`

.

When `lg w >= sqrt(lg(n))`

is better to use `fusion trees`

. However, for `dinamyc fusion trees`

only **expected** `O(lg n/lg w)`

has been achieved.

For example, in a static case, with a 32-bit word, `w = 32`

(as this current implementation that uses scala's Int which is 32-bit signed integer), static van Emde Boas should be used if `n >~ 2^25 ~ 33 millon `

. Otherwise, static `fusion trees`

should be preferred.
In the same scenario, static, for 64-bit word, `w = 64`

, this structure is better than fusion trees if `n >~ 68 billon `

. You're likely to have memory problems with such big numbers, and you may want to switch to a distributed system. Due to its recursive nature, I imagine this structure is easy to implement in a distributed way.

The current implementation, handles scala's Int which is a signed 32-bit number. However, th

- search: O(lg w)
- successor: O(lg w)
- predecessor: O(lg w)
- delete: O(lg w)
- insert: O(lg w)

where **n = 2^w** is the maximum number that can be stored.

- O(n)

- Create performance tests
- Measure memory consumption againt data size (n) and bit (w)
- Create a complete immutable version
- Improve usage of generators for performance tests
- Do performance tests for Immutable Version
- Compare performance between mutable and immutable
- Write predecessor
- Add delete
- Allow any ordering
- Augment the data structure
- Compare to fusion tree
- Compare to
`O(lg n)`

successor/predecessor of trees - Present performance results

- immutable or mutable
- dynamic
- fully tested
- with benchmarks code