Fun fact that was pointed out to me by Viktor: All traditional books on algorithms and data structures that we could find gave the lookup costs of balanced search trees as

But that argument is very unfair: Either we consider a key comparison a

Which of course makes tries much more attractive asymptotic wise. Note that we ignore wall clock times here, which are much more difficult to predict, but in many if not most cases tries are indeed much faster than search trees.

I believe the reason why text books get away with this unfair comparison is that they all present balanced search trees with integer keys:

While tries are traditionally introduced with string examples. If they had used string keys for balanced search trees instead it would have been clear that the key length matters:

The trie examines every key byte at most once, while the search tree can examine every key byte

*O(log n)*(i.e., the depth of the search tree), and the lookup costs of tries as*O(k)*(i.e., the length of the key). At a first glance this is a logarithmic time lookup against a linear time lookup, which makes people nervous when thinking about long keys.But that argument is very unfair: Either we consider a key comparison a

*O(1)*operation, then a tree lookup is indeed in*O(log n)*, but then a trie lookup is in*O(1)*! As the length of the key has to be bounded by a constant to get*O(1)*comparisons, the depth of the trie is bounded, too. Or the length of the key matters, then a trie lookup is indeed in*O(k)*, but then a tree lookup is in*O(k log n)*. We have to compare with the key on every level, and if we are unlucky we have to look at the whole key, which gives the factor*k*.Which of course makes tries much more attractive asymptotic wise. Note that we ignore wall clock times here, which are much more difficult to predict, but in many if not most cases tries are indeed much faster than search trees.

I believe the reason why text books get away with this unfair comparison is that they all present balanced search trees with integer keys:

While tries are traditionally introduced with string examples. If they had used string keys for balanced search trees instead it would have been clear that the key length matters:

The trie examines every key byte at most once, while the search tree can examine every key byte

*log n*times. Thus, the asymptotic complexity of tries is actually better than that of balanced search tries.