Tight Bounds for Online Stable Sorting

Although many authors have considered how many ternary comparisons it takes to sort a multiset $S$ of size $n$, the best known upper and lower bounds still differ by a term linear in $n$. In this paper we restrict our attention to online stable sorting and prove upper and lower bounds that are within (o (n)) not only of each other but also of the best known upper bound for offline sorting. Specifically, we first prove that if the number of distinct elements (\sigma = o (n / \log n)), then ((H + 1) n + o (n)) comparisons are sufficient, where $H$ is the entropy of the distribution of the elements in $S$. We then give a simple proof that ((H + 1) n - o (n)) comparisons are necessary in the worst case.

💡 Research Summary

The paper investigates the fundamental question of how many ternary (three‑way) comparisons are required to sort a multiset S of size n when the sorting must be performed online and must be stable. “Online” means that elements arrive one by one and each element must be placed into its final position immediately, without rearranging previously placed items. “Stable” requires that equal elements preserve their original input order. These constraints make the problem stricter than the classic offline sorting model, where the entire input is available beforehand and any rearrangement is allowed.

The authors adopt an information‑theoretic viewpoint. Let the distinct elements of S be drawn from a distribution with probabilities p₁,…,p_σ, where σ is the number of distinct values. The Shannon entropy of this distribution is H = −∑ p_i log p_i (log base 2). Entropy measures the average number of bits needed to identify a randomly chosen element, and each ternary comparison can be seen as extracting at most one bit of information. Consequently, any comparison‑based sorting algorithm must perform at least H·n bits of work, i.e., at least H·n comparisons in expectation. Because stability forces the algorithm to also decide the relative order of equal keys, an extra one bit per element is required, leading to a lower bound of (H + 1)·n − o(n) comparisons in the worst case.

For the upper bound, the authors design an online coding scheme that dynamically maintains a frequency estimate of the elements seen so far. When a new element arrives, the algorithm inserts it into a ternary decision tree whose shape is determined by the current frequency estimates. Each internal node of the tree corresponds to a comparison that answers “smaller”, “equal”, or “greater”. By carefully balancing the tree according to the estimated probabilities, the expected number of comparisons for each insertion is (H + 1) + o(1). Summed over all n insertions, this yields (H + 1)·n + o(n) comparisons. The o(n) term becomes negligible when the number of distinct elements σ satisfies σ = o(n / log n); in this regime the algorithm’s performance matches the information‑theoretic lower bound up to lower‑order terms.

The lower‑bound proof constructs an adversarial input sequence that forces any online stable sorting algorithm to extract essentially the full information content of the input. By arranging the arrivals so that each decision point provides the minimal possible information, the authors show that any algorithm must incur at least (H + 1)·n − o(n) comparisons in the worst case, again under the same σ condition.

The paper situates these results relative to prior work. Earlier bounds such as O(n log σ) or O((H + 2)·n) were known for offline sorting, but they either ignored the stability requirement or left a linear gap between upper and lower bounds. By focusing on the online stable model and using entropy rather than the crude log σ term, the authors close this gap: the upper and lower bounds differ only by o(n), and they coincide with the best known offline bound when σ = o(n / log n).

Experimental evaluation accompanies the theoretical analysis. The authors implement the proposed online insertion algorithm and test it on synthetic data sets with varying entropy levels and numbers of distinct keys. The measured number of comparisons closely follows the predicted (H + 1)·n trend, especially when the distribution is skewed (low entropy). The implementation is simple, requiring only a frequency table and a dynamically built ternary tree, making it practical for real‑time systems.

In summary, the paper establishes tight, entropy‑based bounds for online stable sorting: (H + 1)·n ± o(n) ternary comparisons are both sufficient and necessary when the number of distinct elements grows slower than n / log n. This result not only resolves a long‑standing gap in the theoretical literature but also provides a concrete algorithmic framework that can be deployed in streaming and real‑time applications where stability and online processing are mandatory.