Predecessor problem

The problem consists of maintaining a set S, which contains a subset of U integers. Each of these integers can be stored with a word size of w, implying that ${\displaystyle U\leq 2^{w}}$. Data structures that solve the problem support these operations:[2]

• predecessor(x), which returns the largest element in S less than or equal to x
• successor(x), which returns the smallest element in S greater than or equal to x

In addition, data structures which solve the dynamic version of the problem also support these operations:

• insert(x), which adds x to the set S
• delete(x), which removes x from the set S

The problem is typically analyzed in a transdichotomous model of computation such as word RAM.

An x-fast trie containing the integers 1 (001₂), 4 (100₂) and 5 (101₂), which can be used to efficiently solve the predecessor problem.

One simple solution to this problem is to use a balanced binary search tree, which achieves (in Big O notation) a running time of ${\displaystyle O(\log n)}$ for predecessor queries. The Van Emde Boas tree achieves a query time of ${\displaystyle O(\log \log U)}$, but requires ${\displaystyle O(U)}$ space.[1] Dan Willard proposed an improvement on this space usage with the x-fast trie, which requires ${\displaystyle O(n\log U)}$ space and the same query time, and the more complicated y-fast trie, which only requires ${\displaystyle O(n)}$ space.[3] Fusion trees, introduced by Michael Fredman and Willard, achieve ${\displaystyle O(\log _{w}n)}$ query time and ${\displaystyle O(n)}$ for predecessor queries for the static problem.[4] The dynamic problem has been solved using exponential trees with ${\displaystyle O(\log _{w}n+\log \log n)}$ query time,[5] and with expected time ${\displaystyle O(\log _{w}n)}$ using hashing.[6]

There have been a number of attempts to prove lower bounds on the predecessor problem, or find what the running time of asymptotically optimal solutions would be. For example, Michael Beame and Faith Ellen proved that for all values of w, there exists a value of n with query time (in Big Theta notation) ${\displaystyle \Omega \left({\tfrac {\log w}{\log \log w}}\right)}$, and similarly, for all values of n, there exists a value of n such that the query time is ${\displaystyle \Omega \left({\sqrt {\tfrac {\log n}{\log \log n}}}\right)}$.[1] Other proofs of lower bounds include the notion of communication complexity.

• Integer sorting
• y-fast trie
• Fusion tree