Three space-economical algorithms for calculating minimum-redundancy prefix codes

The minimum-redundancy prefix code problem is to determine, for a given list W=[ω₁,..., ω_n] of n positive symbol weights, a list L=[l₁,...,l_n] of n corresponding integer codeword lengths such that Σ_i=1 ⁿ 2^-li⩽1 and Σ_i=1ⁿ ω_il_i is minimized. Let us consider the case where W is already sorted. In this case, the output list L can be represented by a list M=[m₁,..., m_H], where m_l, for l=1,...,H, denotes the multiplicity of the codeword length l in L and H is the length of the greatest codeword. Fortunately, H is proved to be O(min(log(1/p₁),n)), where p₁ is the smallest symbol probability, given by ω₁/Σ _i=1ⁿ ω_i. We present the Fast LazyHuff (F-LazyHuff), the Economical LazyHuff (E-LazyHuff), and the Best LazyHuff (B-LazyHuff) algorithms. F-LazyHuff runs in O(n) time but requires O(min(H², n)) additional space. On the other hand, E-LazyHuff runs in O(n+nlog(n/H)) time, requiring only O(H) additional space. Finally, B-LazyHuff asymptotically overcomes, the previous algorithms, requiring only O(n) time and O(H) additional space. Moreover, our three algorithms have the advantage of not writing over the input buffer during code calculation, a feature that is very useful in some applications