A Selectable Sloppy Heap

Abstract

We study the selection problem, namely that of computing the ith order statistic of n given elements. Here we offer a data structure called selectable sloppy heap that handles a dynamic version in which upon request (i) a new element is inserted or (ii) an element of a prescribed quantile group is deleted from the data structure. Each operation is executed in constant time—and is thus independent of n (the number of elements stored in the data structure)—provided that the number of quantile groups is fixed. This is the first result of this kind accommodating both insertion and deletion in constant time. As such, our data structure outperforms the soft heap data structure of Chazelle (which only offers constant amortized complexity for a fixed error rate $0<\epsilon \le 1/2$) in applications such as dynamic percentile maintenance. The design demonstrates how slowing down a certain computation can speed up the data structure. The method described here is likely to have further impact in the field of data structure design in extending asymptotic amortized upper bounds to same formula asymptotic worst-case bounds.

1. Introduction

Together with sorting, selection is one of the most widely used procedures in computer algorithms. Given a sequence A of n numbers and an integer (selection) parameter $1\le i\le n$, the selection problem asks to find the ith smallest element in A. Sorting trivially solves the selection problem; however, a higher level of sophistication is required by a linear time algorithm. A now classic approach for selection [1,2,3,4,5] from the 1970s is to use an element in A as a pivot to partition A into two smaller subsequences and recurse on one of them with a (possibly different) selection parameter i.

The time complexity of this kind of algorithm is sensitive to the pivots used. If a good pivot is used, many elements in A can be discarded, while if a bad pivot is used, the size of the problem may be only reduced by a constant in the worst case, leading to a quadratic worst-case running time. However carefully choosing a good pivot can be time consuming. Choosing the pivots randomly (and thus without much effort) yields a well-known randomized selection algorithm with expected linear running time; see e.g., [6] Ch. 9.2, or [7] Ch. 13.5; or [8], Ch. 3.4, however its worst case running time is quadratic in n.

The first deterministic linear time selection algorithm Select is due to Blum et al. [1]; it is recursive in nature. By using the median of medians of small disjoint groups of the input array (of constant size at least 5), good pivots that reduce the size of the problem by a constant fraction and thereby lead to $O(n)$ time overall can be chosen at low cost in each recursive invocation. More recently, several variants of Select with groups of 3 and 4, also running in $O(n)$ time, have been obtained by Chen and Dumitrescu and independently by Zwick; see [9]. The selection problem, and computing the median in particular, are in close relation with the problem of finding the quantiles of a set.

Quantiles. The kth quantiles of an n-element set are the $k-1$ order statistics that divide the sorted set in k equal-sized groups (to within 1). It is known that the kth quantiles of a set can be computed by a recursive algorithm running in $O(nlogk)$ time ([6], p. 223). Such an algorithm can be modified, if needed, so that the k groups can be also output, say, each as a linked list, within the same overall time. For $2\le i\le k-1$, the ith group of elements (bounded by the $(i-1)$th and the ith quantile) is referred to as the ith quantile group; the first quantile group consists of the elements less than or equal to the first quantile, and the kth quantile group consists of the elements greater than or equal to the $(k-1)$th quantile.

The following problem has been devised by Fredman about 25 years ago for a graduate algorithms course. This paper both generalizes and strengthens that result.

A “very sloppy heap” (abbreviated vsh) is a data structure for performing the following operations on a set S: (i) insert and (ii) delete-small. The latter operation deletes (and returns) an element x which is among the $\lceil n/2\rceil$ smallest elements in the set, where n is the current size of the set. Explain how to implement a vsh in constant amortized time per operation.

Our main result is the following; for the optimality of the dependence on k, see the first remark in Section 4.2.

Theorem 1.

For any fixed integer k, a data structure for dynamic sets exists accommodating each of the following operations in constant time (that depends on k): (i)Inserta new element and (ii)Delete(and return) an element of the ith quantile group of the current set, where $1\le i\le k$. The time per operation is $O(logk)$, which is optimal in a comparison-based model even in an amortized setting.

Background and related problems. Since the selection problem is of primary importance, the interest in selection algorithms has remained high ever since; see for instance [2,5,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24]. In particular, determining the comparison complexity for computing various order statistics including the median has led to many exciting questions, some of which are still unanswered today; in this respect, Yao’s hypothesis on selection ([25], Ch. 4) remains an inspiring endeavor [4,15,23]. A comprehensive review of early developments in selection is provided by Knuth [26]. Computational results on the exact comparison complexity of finding the ith smallest out of n for small $i,n$, have been obtained in [18,27]. We also refer the reader to the dedicated book chapters on selection in [6,7,28,29,30] and the more recent articles [9,31,32], including experimental work [33].

The selection problem is also of interest in an online or dynamic setting, where elements are inserted or deleted. A balanced binary search tree on n distinct elements can be augmented with a size attribute for each node, thereby allowing the retrieval of an element of a given rank in $O(logn)$ time ([6], Ch. 14). We say that the ith smallest element has rank i, where $i=1,\dots ,n$, with ties broken arbitrarily. Further, determining the rank of an element in the data structure can also be done in $O(logn)$ time. Consequently, a dynamic order statistic operation (inserting a new element or deleting an element of a given rank) can be accomplished within the same time bound.

Priority queues (heaps in particular) are ubiquitous data structures; a typical operation set might include Insert, Delete-Min, Decrease-Key (and perhaps also Find-Min, Increase-Key, or other operations). See for instance [34] and the references therein for some new variants and recent developments.

A variant of a priority queue that allows dynamic maintenance of percentiles is the soft heap data structure due to Chazelle [35]; in addition to Create and Meld, the data structure accommodates Insert, Delete and Findmin (Delete x removes item x). Consider a sequence of $m\ge n$ operations after its creation, that includes n Insert operations. For any $0<\epsilon \le 1/2$, a soft heap with error rate $\epsilon$ supports each operation in constant amortized time, except for Insert which takes $O(log1/\epsilon )$ amortized time. The data structure ensures that at most $\epsilon n$ of its items are corrupted (their keys have been artificially raised). Findmin returns the minimum current key (which might be corrupted). In contrast, our data structure uses $O(log1/\epsilon )$ time per operation, where $\epsilon \sim 1/k$, and thereby outperforms the soft heap with respect to the worst-case time per update (insert or delete) operation.

Definition 1.

Let k be a fixed positive integer. A “selectable sloppy heap” (abbreviated ssh) is a data structure for performing the following operations on a set S with n elements:

(a) 

Insertx: a new elementxis inserted.

(b) 

Deletei: this deletes (and returns) some unspecified elementxwhich belongs to theith quantile group of the current set, where$1\le i\le k$; if$n<k$, the deleted element is not subject to any requirement.

Outline of the paper. To explain the main challenges and introduce the main ideas, we first sketch several preliminary implementations of the data structure, meeting suboptimal (in k) benchmarks: (i) $O(klogk)$ amortized time per operation for the first variant in Section 2; (ii) $O(klogk)$ worst-case time per operation for the second variant in Section 2; (iii) $O(logk)$ amortized time per operation for the third variant in Section 2. We then further refine these methods in Section 3 to obtain an optimal implementation of the data structure running in $O(logk)$ worst-case time per operation. In particular, for constant k, the second variant in Section 2 and the (main) variant in Section 3 run in $O(1)$ worst-case time per operation. We conclude in Section 4 with applications and some remarks.

Comments and notations. Duplicate elements are easily handled by the design. Each operation request is associated with a discrete time step, i.e., the jth operation occurs during the jth time step, where $j=1,2,\dots$ Without affecting the results, the floor and ceiling functions are omitted in the descriptions of the algorithms and their analyses.

Let A be a set; we write $x\le A$ if $x\le a$ for every $a\in A$. The size of a bucket $\mathtt{b}$, i.e., the number of elements in $\mathtt{b}$, is denoted by $s(\mathtt{b})$. If buckets ${\mathtt{b}}^{\prime }$ and ${\mathtt{b}}^{″}$ merge into a new bucket $\mathtt{b}$, written as ${\mathtt{b}}^{\prime }\cup {\mathtt{b}}^{″}\to \mathtt{b}$, we clearly have $s({\mathtt{b}}^{\prime })+s({\mathtt{b}}^{″})=s(\mathtt{b})$. Similarly, if a bucket $\mathtt{b}$ splits into two buckets ${\mathtt{b}}^{\prime },{\mathtt{b}}^{″}$, written as $\mathtt{b}\to {\mathtt{b}}^{\prime }\cup {\mathtt{b}}^{″}$, then we have $s(\mathtt{b})=s({\mathtt{b}}^{\prime })+s({\mathtt{b}}^{″})$ as well.

2. Some Ideas and Preliminary Suboptimal Solutions

A first variant with$O(klogk)$amortized time per operation. Let n denote the current number of elements in the data structure, with the elements being stored in a linear list (or an array). By default (if n is large enough) the algorithm proceeds in phases.

If $n<3k$, and no phase is under way, proceed by brute force: For Insert, add the new element to the list; for Delete i, compute the elements in the ith quantile group and delete (return) one of them arbitrarily. Since k is constant, each operation takes time $O(3k)=O(k)$.

If $n\ge 3k$, and no phase is under way, start a new phase: Reorganize the data structure by computing the $3k$th quantiles of the set and the corresponding $3k$ groups; store each group in a list (bucket) of size $n/(3k)$. The next $n/(3k)$ operations make up the current phase. Process each of these $n/(3k)$ operations by using exclusively elements stored in these $3k$ buckets. For Insert, add the new element to an initially empty overflow bucket (an empty overflow bucket is created at each reorganization). For Delete i, remove any element from the bucket $3i-1$, i.e., from the middle third of the ith quantile group (out of the total k).

The reorganization takes $O(nlogk)$ time and is executed about every $n/(3k)$ steps, where each operation counts as one step. The resulting amortized cost per operation is

$$O\left(\frac{nlogk}{n/k}\right)=O(klogk).$$

A second variant with$O(klogk)$worst-case time per operation. The above idea is next refined so as to obtain the above expression as a worst-case time bound per operation. However, we need a larger set of quantiles: $9k$ buckets will suffice (a more detailed analysis likely gives a better bound). We can assume that $n\ge 9k$. The algorithm proceeds in phases: Each phase starts with a reorganization, namely computing the $(9k)$th quantiles and the corresponding quantile groups in time $O(nlog(9k))=O(nlogk)$. For Insert, add the new element to an initially empty overflow bucket (an empty overflow bucket is created at each reorganization). For Delete i, remove any element from the bucket $9i-4$, i.e., from the middle fifth of the ith quantile group (out of the total k).

There are $n/(9k)$ operations, i.e., $n/(9k)$ steps following each reorganization until the results of the next reorganization become available. Assume that the data structure holds n items when the current reorganization starts (n is redefined at the start of each reorganization) and there are old buckets to use until the reorganization is finalized. That is, after that many steps, new buckets—however, with an old content—become available. These buckets are used for the next $n/(9k)$ operations, and so on.

To transform the $O(1)$ amortized time guarantee into a $O(1)$ worst-case guarantee for each operation, spread the execution of reorganization over the next $n/(9k)$ operations, i.e., over the entire phase. The resulting time per operation is bounded from above by

$$O\left(\frac{nlogk}{n/(9k)}\right)=O\left(klogk\right).$$

(1)

Since Delete is serviced from the existent buckets and Insert is serviced using the overflow bucket, each operation involves inserting or deleting one element from a list; thus each operation takes $O(klogk)$ time to process.

New buckets become available about every other $n/(9k)$ operations; this is a rather imprecise estimate because the current number of elements, n, changes. Since a reorganization is spread out over multiple steps, the result becomes available with some delay, and moreover, its content is (partially) obsolete. Assume there are n elements at the start of a reorganization during phase $\mathsf{\Phi }$. At the end of the reorganization, the data structure reflects the earlier situation when there were n elements; and this organized structure is used to answer queries during the following phase ${\mathsf{\Phi }}^{\prime }$. As such, the number of elements, $n^{\prime }$, in the data structure at operation time (during ${\mathsf{\Phi }}^{\prime }$), belongs to the interval

$$\left[{\left(1-\frac{1}{9k}\right)}^{2}n,{\left(1+\frac{1}{9k}\right)}^{2}n\right].$$

(2)

The total number of operations in phases $\mathsf{\Phi }$ and ${\mathsf{\Phi }}^{\prime }$ is at most

$$\frac{n}{9k}+\frac{n+n/(9k)}{9k}=\frac{2n}{9k}+\frac{n}{81k^2}={\left(1+\frac{1}{9k}\right)}^{2}n-n.$$

(3)

To verify that the data structure operates as intended, one needs to check that the rank of a deleted element belongs to the required interval (quantile group). The key observation is that any one operation can affect the rank of any element by at most 1: To be precise, only Insert or Delete of a smaller element can increase the rank of an element by 1 or decrease the rank of an element by 1, respectively.

By the above observation, the rank of a deleted element lies in the interval

$$\left[\frac{9i-5}{9k}n-{\left(1+\frac{1}{9k}\right)}^{2}n+n,\frac{9i-4}{9k}n+{\left(1+\frac{1}{9k}\right)}^{2}n-n\right],\mathrm{where}1\le i\le k.$$

(4)

We need to show that this rank belongs to the interval

$$\left[\frac{i-1}{k}{n}^{\prime },\frac{i}{k}{n}^{\prime }\right].$$

(5)

It suffices to verify that

$$\frac{9i-5}{9k}n-{\left(1+\frac{1}{9k}\right)}^{2}n+n\ge \frac{i-1}{k}{\left(1+\frac{1}{9k}\right)}^{2}n,$$

(6)

and respectively that

$$\frac{9i-4}{9k}n+{\left(1+\frac{1}{9k}\right)}^{2}n-n\le \frac{i}{k}{\left(1-\frac{1}{9k}\right)}^{2}n.$$

(7)

Inequality (6) is equivalent to

$$\begin{array}{cc}\hfill 1+\frac{9i-5}{9k}& \ge {\left(1+\frac{1}{9k}\right)}^2\left(1+\frac{i-1}{k}\right),\mathrm{or}\hfill \\ \hfill 1+\frac{4}{9(k+i-1)}& \ge 1+\frac{2}{9k}+\frac{1}{81k^2}.\hfill \end{array}$$

Since $1\le i\le k$, it is enough to verify that

$$\frac{4}{9(2k-1)}\ge \frac{2}{9k}+\frac{1}{81k^2},\mathrm{or}\frac{2}{2k-1}\ge \frac{1}{9k}.$$

Inequality (7) is equivalent to

$$\begin{array}{cc}\hfill \frac{9i-4}{9k}+\frac{2}{9k}+\frac{1}{81k^2}& \le \frac{i}{k}{\left(1-\frac{1}{9k}\right)}^2,\mathrm{or}\hfill \\ \hfill \frac{1}{9k}-2& \le \frac{i}{9k^2}-\frac{2i}{k},\mathrm{or}\hfill \\ \hfill (1-18k)& \le \frac{i}{k}(1-18k).\hfill \end{array}$$

Similarly, this follows from the inequality $1\le i\le k$.

A third variant with$O(logk)$amortized time per operation. We briefly describe an implementation achieving $O(logk)$ amortized time per operation that is tailored on the idea of a B-tree; this variant was suggested by Fredman [36]. Use a balanced binary search tree $\mathcal{A}$ with $\mathsf{\Theta }(logk)$ levels storing $O(k)$ splitting keys at the leafs. Each leaf comprises a bucket of $\mathsf{\Theta }(n/k)$ items, with order maintained between buckets, but not within buckets.

As mentioned earlier, a balanced binary search tree on distinct elements can be augmented with a size attribute for each node, thereby allowing the retrieval of an element of a given rank in time proportional to its height. Using this mechanism, $\mathcal{A}$ can be augmented with such information allowing the retrieval of a leaf containing elements within a given quantile group, as needed for answering an operation request, in $O(logk)$ time.

When an insertion causes a bucket to become too large, it gets split into two buckets by performing a median selection operation. The balanced binary search tree is correspondingly updated by deleting a leaf and inserting two new ones. Small buckets (due to deletions) get merged; the balanced binary search tree is correspondingly updated by deleting two leaves and inserting a new one. A bucket of size m, once split, won’t get split sooner than another $\mathsf{\Omega }(m)$ operations.

When the number of elements doubles (or halves), a tree reorganization is triggered that partitions the present items into $6k$ uniform sized buckets, so that the new common bucket size m is $n/(6k)$ items. These event-triggered reorganizations ensure that buckets do not become too small unless they are target of deletions; similarly, buckets do not become too large unless they are target of insertions. Since the reorganization cost is $O(nlogk)$, and $\mathsf{\Omega }(n)$ operation requests take place between successive reorganizations, this scheme yields $O(logk)$ amortized time per operation.

Observe that when k is a constant, the 2nd variant supports operations in constant time.

3. A Variant with Optimal $O(logk)$ Worst-Case Time per Operation

A brief examination of the approach in the 3rd variant reveals two bottlenecks in achieving $O(logk)$ worst-case time per operation: The median computation that comes with splitting large buckets and the tree reorganization that occurs when n doubles (or halves). We briefly indicate below how ideas from the 2nd and 3rd early variants are refined to obtain $O(logk)$ worst-case time per operation; in particular, $O(1)$ time for constant k. It is shown in the process how execution in parallel of several sequential procedures can lead to a speed up of the data structure. This only means that some tasks are run as “background processes”, as no real parallel processing is used in this paper. The idea of slowing down for being faster has also appeared in other forms; see, e.g., [37].

A balanced BST for $\mathsf{\Theta }(k)$ keys is used, subdividing the data into $O(k)$ buckets. Each bucket is maintained as a linked list. A size attribute is associated with each node reflecting the number of elements stored in the subtree rooted at the respective node. Modifications in the data structure at each operation are reflected in appropriate updates of the size attributes at the $O(logk)$ nodes of the $O(1)$ search paths involved, in $O(logk)$ time overhead per operation.

If n is the current number of elements, each bucket holds at most $n/(3k)$ elements, and so each of the k quantile groups contains at least one of the buckets entirely. By choosing one such bucket at the end of the search path in the BST for executing a Delete operation from the ith quantile group guarantees its correctness.

The n elements are kept in $\mathsf{\Theta }(k)$ buckets of maximum size $O(n/k)$ that form the $\mathsf{\Theta }(k)$ leaves of a balanced binary search tree $\mathcal{A}$. As in the third variant (in Section 2), each leaf holds a bucket, with order maintained between buckets, but not within buckets. Buckets that become too large are split in order to enforce a suitable upper limit on the bucket size. Median finding procedures along with other preparatory and follow-up procedures accompanying bucket splits are scheduled as background computation, as in the second variant (in Section 2).

Our data structure merges small buckets in order to keep the number of buckets under control and renounces the periodic tree reorganizations by introducing new elements of design: a round robin process and a priority queue jointly control the maximum bucket size and the number of buckets in the BST. These mechanisms are introduced to prevent buckets becoming too small or too large as an effect of changes in the total number of elements, n, and not necessarily as an effect of operations directed to them.

Outline and features. Let $N=12k$. For illustrating the main ideas, assume now that $n\ge N$. The buckets are linked in a doubly-linked linear list $\mathcal{B}$, in key order; adding two links between the last and the first bucket yields a circular list $\mathcal{C}$, referred to as the round robin list. We note that $\mathcal{B}$ and $\mathcal{C}$ are two views of the same data structure.

Each operation request translates to locating a suitable bucket for implementing the request. The circular list is traversed in a round robin fashion, so that the current round robin bucket in the list is also examined during the current operation request. The round robin process ensures that (i) the buckets do not exceed their maximum capacity, and (ii) certain “long-term” preparatory bucket-splitting procedures are run in the background over a succession of non-consecutive discrete time steps allocated to the same bucket.

Each bucket split entails a merge-test for the pair of adjacent buckets with the minimum sum of sizes. The process of merging adjacent buckets in $\mathcal{B}$ is controlled by a priority queue in the form of a binary min-heap $\mathcal{H}$. If $\left|\mathcal{B}\right|=t$, i.e., there are t buckets, $\mathcal{H}$ holds the $t-1$ sums of sizes $s(\mathtt{b})+s({\mathtt{b}}^{+})$, for buckets $\mathtt{b}\in \mathcal{B}$; here ${\mathtt{b}}^{+}$ denotes the bucket that follows $\mathtt{b}$ in $\mathcal{B}$. A merge is made provided the minimum value at the top of $\mathcal{H}$ is below some threshold; and $\mathcal{A}$, $\mathcal{B}$ and $\mathcal{H}$ are correspondingly updated. Merging adjacent buckets ensures that the total number of buckets remains under control, regardless of which buckets are accessed by operation requests.

The process of splitting buckets in $\mathcal{B}$ is controlled by a round robin process. A bucket split is initiated as a background process provided its size (as a current bucket) is above some threshold. Splitting buckets ensures that buckets sizes remains under control, regardless of which buckets are accessed by operation requests. The bucket granularity is needed to ensure that the sloppy heap data structure responds correctly to operation requests.

Elements of the design. We highlight: (i) Use of the priority queue $\mathcal{H}$ to keep the number of buckets under control; (ii) use of the round robin process to detect large buckets, and (iii) running the procedures involved at different rates as needed to ensure that certain task deadlines and precedence constraints among them are met. The data structure maintains the following two invariants:

$\mathcal{I}1$

Each bucket contains between 1 and $n/(3k)$ elements; there is no limit from below imposed on the bucket size.

$\mathcal{I}2$

The number of buckets is between $3k$ and $N=12k$, as implied by the maximum bucket size and a later argument based on the rules of operation (on merging adjacent buckets); see Action 2 and Lemma 1.

Recall that all $\mathsf{\Theta }(k)$ buckets are linked in a circular round robin list: in key order, and with the last bucket linked to the first one. A pointer to the current round robin bucket (initialized arbitrarily, say, to the first bucket) is maintained. Each operation request advances this position in the list by one slot. Observe that every bucket becomes the round robin bucket about every $\mathsf{\Theta }(k)$ discrete time steps. Further, each operation request leads via the search path in $\mathcal{A}$ to one of the buckets, referred to as the operation bucket. Executing one operation is done by a sequence of actions performed in the operation bucket and the round robin bucket; these are referred to as the current buckets. All these actions are therefore associated with the same discrete time step. Every bucket update (this includes creation or deletion of buckets) entails a corresponding update of the binary heap $\mathcal{H}$ in the (at most) two heap elements $s(\mathtt{b})+s({\mathtt{b}}^{+})$ that depend on it.

A bucket is declared large if its current size exceeds $9/10$ of the maximum allowed, i.e., if the current size exceeds $9n/(30k)$. All other buckets are declared regular. Each operation may cause an update in the status of the round robin bucket and the operation bucket (among large and regular).

Action 1. Execute the requested operation: Either add a new element to the respective bucket, or delete an arbitrary element from it. If the operation bucket becomes empty as a result of the current Delete operation, it is deleted, and $\mathcal{B}$, $\mathcal{H}$ (and t) are correspondingly updated to reflect this change in $O(logk)$ time. Status updates in the current two buckets are made, if needed. If a median finding procedure or a follow up procedure is under way in the current operation bucket or the current round robin bucket (see details below), the next segment consisting of 500 (or less) elementary operations of this background procedure is executed. These are instructions usually counted in standard analyses of algorithms, such as arithmetic operations, data movements, comparisons, etc. Specifically, we assume that the median of n elements can be found in at most $10n$ elementary operations.

Action 2 (merge-test). Let $\sigma :=s(\mathtt{b})+s({\mathtt{b}}^{+})$ be the minimum value at the top of the heap $\mathcal{H}$. If $\sigma \le 5n/(30k)$, merge the two buckets into one: $\mathtt{b}\cup {\mathtt{b}}^{+}\to \mathtt{b}$, and update the tree $\mathcal{A}$, the bucket list $\mathcal{B}$ and the binary heap $\mathcal{H}$ to reflect this change: (i) Delete the two buckets that are merged and insert the new one that results into $\mathcal{A}$ and $\mathcal{B}$; this only involves simple list handling and adjusting attributes at the $O(logk)$ nodes of $\mathcal{A}$ on the $O(1)$ search paths involved. (ii) extract the minimum element from $\mathcal{H}$ and insert the two new sum of sizes of two adjacent buckets formed by the new bucket into $\mathcal{H}$ (if they exist).

Handling of $\mathcal{A},\mathcal{B}$ and $\mathcal{H}$ takes $O(logk)$ time, $O(1)$ time, and $O(logk)$ time, respectively. In particular, this action ensures that the size of any new bucket obtained by merge is at most $5n/(30k)$. It is worth noting that: a bucket for which a partitioning procedure is under way, as described below, cannot be part of a pair of buckets to merge (i.e., passing the merge-test); bucket merges are not scheduled as background processes.

Action 3 (finalizing a split). Similar to the merge operations in Action 2, finalizing the split can be completed in $O(logk)$ time: It essentially involves updating $\mathcal{A}$, $\mathcal{B}$, and $\mathcal{H}$. It will be shown subsequently that the size of any new bucket resulting from a split is in the range $[4n/(30k),6n/(30k)]$.

Besides Actions $1-3$, there are actions associated with procedures running in the background, whose execution is spread out over a succession of non-consecutive discrete time steps allocated to the same bucket. The procedures are in preparation of splitting large buckets.

Splitting a large bucket. For simplicity of exposition and without loss of generality, we may assume that $n\ge ck$, for a suitable constant $c>0$ (one can take $c=130$). It is worth noting that a bucket may become large by repeated deletions from other buckets leading to a reduction in the total number of items, n; moreover, by the same reasoning, several buckets may become large at the same time.

Recall that a bucket $\mathtt{b}$ is large if $s(\mathtt{b})\ge 9n/(30k)$. When such condition is reached, no background procedure is active in that bucket; this condition launches a bucket split described below. Let $n_0=n$ be the number of elements existent when the large bucket is detected and the procedure is initiated. Place $8.8n_0/(30k)$ elements into (a main part) $P_1$ and the remaining $s(\mathtt{b})-|P_1|$ elements into (a secondary part) $P_2$. It is worth noting at this point that even this first step of partitioning $\mathtt{b}$ into $P_1$ and $P_2$ does not take $O(1)$ time and is in fact part of the background procedure; indeed, each bucket is stored as a linked list and as such, partitioning it into two lists of prescribed sizes requires scanning the list; its size is $\mathsf{\Theta }(n/k)$.

There are two possible cases: (i) $\mathtt{b}$ becomes large as a result of insertion into $\mathtt{b}$, and (ii) $\mathtt{b}$ becomes large while being inactive and n is decreasing (as a result of deletions from other buckets). On one hand, $s(\mathtt{b})\ge 9n/(30k)$, thus $0.2n_0/(30k)\le \left|P_2\right|$; on the other hand, $s(\mathtt{b})\le 9(n+12k)/(30k)\le 9n/(30k)+4$, and thus $|P_2|\le 0.2n_0/(30k)+4$, since at the latest, a large bucket will be detected and dealt with at the step when it becomes a round robin bucket, namely in at most $12k$ steps by Lemma 1 (forthcoming at the end of this section). Consequently, in either case, we have $0.2n_0/(30k)\le \left|P_2\right|\le 0.2n_0/(30k)+4$ when the bucket splitting procedure is initiated. Any insertions and deletions from the current bucket until the split is finalized are performed using the secondary part $P_2$. A balanced partition of the current bucket (as explained below) will be obtained in at most $n_0/10$ time steps.

Consider the following $n_0/10$ operation requests. By Lemma 1 below, the number of buckets is at most $12k$ at any time, and so at least $(n_0/10)/(12k)=n_0/(120k)$ time steps are allocated to $\mathtt{b}$ in the round robin process by the $n_0/10$ time mark. Let $t_1$, where $n_0/(120k)\le t_1<n_0/10$, mark the first occurrence when a total of $n_0/(120k)$ discrete time steps have been allocated to $\mathtt{b}$ (as operation steps or round robin steps). As shown next, this number of steps suffices for finalizing the balanced partition and the split of $\mathtt{b}$. The process calls two procedures, labeled (A) and (B):

(A) Start a median finding procedure, i.e., for finding the two quantile groups $Q_1,Q_2$ of $P_1$: An element $m\in Q_1\cup Q_2=P_1$ is found so that $Q_1\le m\le Q_2$ and $\left|\right|Q_1|-|Q_2\left|\right|\le 1$. At the point when this procedure is launched, the computational steps are scheduled so that every time the bucket gets accessed (either as the operation bucket or as the round robin bucket), 500 computational steps for selecting the median element of $P_1$ take place. Assume for concreteness that median finding on an input set S takes at most $10\left|S\right|$ elementary operations; when applied to $P_1$, we have $|P_1|\le 8.8n_0/(30k)$, and thus $88n_0/(30k)$ elementary operations suffice. At the rate of 500 per discrete time step, it follows that $88n_0/(15000k)\le n_0/(160k)$ time steps suffice for finding the median of $P_1$.

(B) After the median has been determined, a follow up procedure is initiated in the same bucket. It aims at reducing and finally eliminating the leftover of $P_2$, so that in another $n_0/(480k)$ discrete steps, a balanced partition of the current bucket is obtained. The follow up procedure starts with the two quantile groups of the same size, $4.4n_0/(30k)$, as created by the median finding procedure, by comparing each element of $P_2$ against m and properly placing it in one of the two groups. This procedure runs at the rate of 10 items per discrete time step accessing the current bucket (either as the operation bucket or as the round robin bucket), until finally the partitioning process is completed with all elements in the current bucket properly placed against the pivot m. Note that $|P_2|\le 0.2n_0/(30k)+4+n_0/(480k)\le 0.5n_0/(30k)$ at any time during the background procedure (as implied by the inequality $n\ge 130k$). At the rate of 10 items per discrete time step, it follows that $0.5n_0/(300k)\le n_0/(480k)$ time steps suffice for completing the follow up procedure.

The two procedures terminate within a total of at most $n_0/(160k)+n_0/(480k)=n_0/(120k)$ discrete time steps, as required. The parameters are chosen so that the split takes place before the large bucket $\mathtt{b}$ becomes illegal.

At most $n_0/10$ operation requests have been made since the partitioning procedure was initiated and so $0.9n_0\le n\le 1.1n_0$; thus, in terms of the current number of elements, n, the split of a large bucket $\mathtt{b}$ (this qualification refers to the time when the partitioning procedure was initiated) produces two smaller buckets ${\mathtt{b}}^{\prime }$, ${\mathtt{b}}^{″}$, where

$$\frac{4n}{30k}\le \frac{4.4n_0}{30k}\le s({\mathtt{b}}^{\prime }),s({\mathtt{b}}^{″})\le \frac{4.4n_0}{30k}+\frac{0.4n_0}{30k}+\frac{n_0}{480k}\le \frac{5n_0}{30k}\le \frac{6n}{30k}.$$

(8)

Remark 1.

Let $\mathtt{b}$ be a new bucket produced in the current operation. If $\mathtt{b}$ is generated by a split operation, then  $\frac{4n}{30k}\le s(\mathtt{b})\le \frac{6n}{30k}$ by (8). If $\mathtt{b}$ is generated by a merge operation, then $s(\mathtt{b})\le \frac{5n}{30k}$ by the merge-test.

Analysis of merging buckets and maintaining the two invariants. To prove that the two invariants $\mathcal{I}1$ and $\mathcal{I}2$ are maintained, we need the following key fact.

Lemma 1.

The number of buckets is at most $N=12k$ at any time.

Proof. 

Let t denote the number of buckets after the current operation is executed, and $j=1,2,\dots$ denote the discrete time steps. Let $B_1,\dots ,B_t$ be the buckets after the current step in key order. Write $a_i=s(B_i)$, for $i=1,\dots ,t$. We proceed by induction on j and show that, if the number of buckets in $\mathcal{A}$ (and $\mathcal{B}$) is at most N after each of the preceding N time steps, it remains at most N after the current time step. Observe that the number of buckets can only increase by one after a bucket split, and there can be at most two splits associated with a discrete time step. The induction basis is $j\le N/2$, and then indeed, we have $t\le 2j\le N$, as required.

For the induction step, assume that the number of buckets is at most N after the previous operation. If no bucket splits occur during the execution of the current operation, the number of buckets remains unchanged, and is thus still at most N after the current operation. If bucket splits occur, it suffices to show that the number of buckets is at most N after each split. Consider a split operation, and let $\sigma :=s(\mathtt{b})+s({\mathtt{b}}^{+})$ be the minimum value at the top of the heap $\mathcal{H}$ after the split. There are two cases:

Case 1.$\sigma \le 5n/(30k)$, and thus the merge is executed. Consequently, the number of buckets after the split is still at most N, as required.

Case 2.$\sigma >5n/(30k)$, and thus no merge is executed. Since $\mathcal{H}$ is a min-heap, we have

$$a_i+a_{i+1}>\frac{5n}{30k},\mathrm{for}i=1,\dots ,t-1.$$

(9)

Adding these $t-1$ inequalities yields

$$2n=2\sum _{i=1}^t{a}_i>(t-1)\frac{5n}{30k},$$

or $t\le 12k=N$, as claimed, and concluding the induction step. □

Summary of the analysis. As seen from the preceding paragraphs and the fact that the number of buckets is $t=O(k)$, the total time per operation is $O(logt)+O(logk)+O(1)=O(logk)$, as required.

4. Conclusions

4.1. Technical Remarks

1. An argument due to Fredman [36] shows that executing a sequence of n operations (from among Insert and Delete i, where $1\le i\le k$) requires $\mathsf{\Omega }(nlogk)$ time in the worst case, regardless of the implementation of the data structure. The argument relies on the information theory lower bound ([26], Ch. 5.3.1). (For completeness, it is included in the Appendix A.)

2. In addition to the two operations provided Insert and Delete i, the following operation can be also accommodated at no increase in cost: Read i: this returns some element x which belongs to the ith quantile group of the current set, where $1\le i\le k$; the element remains part of the data structure.

3. An alternative solution (to that outlined in Section 3) achieving $O(logk)$ worst-case time per operation was conceived by Fredman [36] (after the author of the current paper had communicated him the main result). (i) His solution avoids the need to merge small buckets (in order to keep the number of buckets under control) by maintaining two running copies of the data structure and performing periodic tree reorganizations that create uniform-sized buckets. Buckets that become large are split using a mechanism similar to that devised here in Section 3. Without going into the details, we point out that the decision to avoid merging small buckets comes at a high price. The main reasons are the need to maintain multiple running copies of the data structure (with two copies under permanent construction, etc), handling subtle consistency issues generally hard to satisfy, and the likely reduced speed caused by the above items. (ii) Another cumbersome approach claimed to be a simplification can be found in his subsequent arXiv posting [38]. As such, neither alternative solution—(i) or (ii) above—matches in simplicity the one given here.

4. As mentioned earlier, the $O(log1/\epsilon )$ amortized complexity of the soft heap is optimal. However, this does not hold for the worst-case complexity in regard to its Insert, Delete and Findmin operations. In contrast, the $O(log1/\epsilon )$ worst-case complexity per operation of the selectable sloppy heap is optimal (where $\epsilon \sim 1/k$).

5. Although the 2nd variant in Section 2 has a suboptimal dependence in k, this variant may provide an attractive solution for implementation, particularly for small values of k.

4.2. Applications and Concluding Remarks

1. The new data structure finds applications in settings with large dynamic sets where insertions and deletions need to be handled fast, and there is no need to be very precise with the ranks of the elements handled. One such application is approximate sorting. An array of n elements is said to be L-sorted if for every $i\in \left[n\right]$, we have $|\mathtt{rank}(a_i)-i|\le L$; see also [39,40]. As shown by the lower bound argument in the Appendix A, the selectable sloppy heap can be used to L-sort n elements in $O(nlog(n/L))$ time.

2. As mentioned in the introduction, the selection problem, and computing the median in particular, are in close relation with the problem of finding the quantiles of a set. A typical use of the median relies on its property of being both larger or equal and smaller or equal than a constant fraction of the n elements. Following Yao [25], an element (think of a player, in the context of tournaments) is said to be $(i,j)$-mediocre if it is neither among the top i nor among the bottom j of a totally ordered set S. As such, an element from the middle third quantile group of an n-element set is $(\lfloor n/3\rfloor ,\lfloor n/3\rfloor )$-mediocre; or simply mediocre, for short. Repeatedly returning a mediocre element in a dynamic setting (with an initially empty set) can thus be accomplished via the new data structure, by setting $k=3$ and then repeatedly executing Delete 2 or Read 2, as needed, at a minimal (constant) query cost. Similarly, putting $k=100$ sets up the data structure for dynamic percentile maintenance in $O(1)$ time per operation; to the best of our knowledge, this outperforms previously available data structures with respect to this application; e.g., the soft heap data structure of Chazelle [35] only offers constant amortized time per operation.

3. This is a continuation of our earlier discussion in Section 1 on using BSTs in the context of dynamic selection taking into account the new data structure. Traditionally, search trees do not allow duplicate keys; it is however an easy matter to augment each node of such a tree with a multiplicity attribute associated with each distinct key. In particular, the multiplicity attribute is taken into account when computing the size attribute of a node. Now having a balanced search tree on n items augmented as described, insertion, deletion, and search all take $O(logn)$ time.

Our construction method can be used for any parameter k, with $2\le k\le n$. The data structure obtained in this way can be viewed as an approximate search tree. In particular, one can search for a given key and the approximate rank of a search key can be determined. To be precise, the following hold: (1) For every k, with $2\le k\le n$, an approximate search tree on n items (duplicate keys allowed) can be constructed in $O(nlogk)$ time. (2) Search for a given key takes $O(n/k+logk)$ time per operation; its approximate rank, i.e., the quantile group to which it belongs (out of k), can be reported in $O(logk)$ time (regardless of the presence of the key!). (3) Insertion can be accommodated in $O(logk)$ time per operation. (4) Deletion of an unspecified key from a given quantile group (out of k) takes $O(logk)$ time; while deletion of a given key takes $O(n/k+logk)$ time.

It is worth noting that the approximate search tree we just described appears competitive when k is small and the search function is infrequently used. Then insertion and deletion of an unspecified key from a given quantile group (out of k) takes $O(logk)$ time (the deleted element is revealed after the operation); e.g., if $k=O(logn)$, these operations take $O(loglogn)$ time. On the other hand, the approximate search tree above is no real competitor for the exact solution previously discussed; indeed, no choice of k in our data structure would allow an improvement in the performance of all three basic operations.

4. Interestingly enough, most applications envisioned by Chazelle [35] for the soft heap (i.e., four items from his list of five) can be dealt with using the selectable sloppy heap; these include dynamic maintenance of percentiles, linear-time selection, and two versions of approximate sorting. One can observe that the complexity analysis for the soft heap, of the error rate in particular, is more complicated than that for the selectable sloppy heap; moreover, special effort is required to ensure that the space needed by the soft heap is linear in the number of items present. In at least one application, approximate sorting, the analysis of doing that with a soft heap is more involved than that for using our structure for this task. Needless to say, the soft heap only allows deletion of small items. As such, the new data structure presented here compares favorably to the soft heap with respect to insertion and deletion. Moreover, the constant amortized guarantee per operation is replaced by the stronger constant worst-case guarantee per operation in our case.

It is worth recalling that the soft heap was designed with a specific application in mind, minimum spanning trees. Given a connected graph $G=(V,E)$, where $\left|V\right|=n$, $\left|E\right|=m$, with weighted edges, Chazelle [41] showed that a minimum spanning tree (MST) can be computed by a deterministic algorithm in $O(m\alpha (m,n))$ time, where $\alpha$ is the (slowly growing) inverse of the Ackermann function. A randomized linear-time algorithm was given by Karger et al. [42]. The question of whether the selectable sloppy heap can be used for MST computation is left open.

5. The method described here is likely to have further impact in the field of data structure design in extending asymptotic amortized upper bounds to same formula asymptotic worst-case bounds (i.e., by a constant factor adjustment); possible candidates are for instance those that involve periodic restructuring of the data structure.