Numeri interi di "quasi ordinamento" in tempo lineare

Sono interessato a ordinare una matrice di valori interi positivi $L = v_1, \ldots, v_n$ in tempo lineare (nel modello RAM con misura del costo uniforme, ovvero, gli interi possono avere dimensioni logaritmiche fino a quando si presume che le operazioni aritmetiche su di essi prendere il tempo unitario). Naturalmente, questo è impossibile con gli algoritmi di ordinamento basati sul confronto, quindi sono interessato a calcolare un ordinamento "approssimativo", cioè calcolare una permutazione $v_{\sigma(1)}, \ldots, v_{\sigma(n)}$ di $L$che non è davvero ordinato, in generale, ma una "buona approssimazione" della versione ordinata di $L$ . Presumo che stiamo ordinando gli interi in ordine decrescente perché rende il sequel un po 'più piacevole da affermare, ma ovviamente si potrebbe dire il problema al contrario.

Un possibile criterio per un ordinamento approssimativo è il seguente (*): lasciando che $N$ sia $\sum_i v_i$ , per ogni $1 \leq i \leq n$ , è necessario che $v_{\sigma(i)} \leq N/i$ (ovvero il "quasi-ordinato "l'elenco è limitato dall'alto dalla funzione decrescente $i \mapsto N/i$ ). È facile vedere che l'ordinamento attuale soddisfa questo: $v_{\sigma(2)}$ deve essere maggiore di $v_{\sigma(1)}$quindi è al massimo $(v_{\sigma(1)} + v_{\sigma(2)})/2$ che è $\leq N/2$ , e in generale $v_{\sigma(i)}$ deve essere maggiore di $(\sum_{j \leq i} v_{\sigma(i)})/i$ che è $\leq N/i$ .

Ad esempio, il requisito (*) può essere raggiunto dall'algoritmo seguente (suggerito da @Louis). La mia domanda è: esiste un lavoro esistente su questo compito di "quasi ordinare" numeri interi in tempo lineare, imponendo alcuni requisiti come (*) che l'ordinamento reale soddisferebbe? L'algoritmo di seguito, o qualche sua variante, ha un nome stabilito?

Modifica: risolto l'algoritmo e aggiunte ulteriori spiegazioni

Algoritmo:

INPUT: V an array of size n containing positive integers
OUTPUT: T

N = Σ_{i<n} V[i]
Create n buckets indexed by 1..n
For i in 1..n
| Add V[i] into the bucket min(floor(N/V[i]),n)
+

For bucket 1 to bucket n
| For each element in the bucket
| | Append element to T
| +
+

Questo algoritmo funziona come previsto per i seguenti motivi:

1. Se un elemento $v$ è nel bucket $j$ allora $v ≤ N/j$ .

   $v$ viene inserito nel bucket$j=\min(N/v,n)$ , quindi$j ≤ \lfloor N/v\rfloor ≤ N/v$

2. Se un elemento $v$ è nel bucket $j$ allora $N/(j+1) < v$ oppure $j=n$ .

   $v$ viene inserito nel bucket$j=\min(N/v,n)$ , quindi$j = \lfloor N/v \rfloor$ o$j=n$ . Nel primo caso$j=\lfloor N/v\rfloor$ che significa$j ≤ N/v < j+1$ e quindi$N/(j+1) < v$ .

3. Per $j<n$ , ci sono al massimo $j$ elementi nei bucket da 1 a $j$ .

   Sia $j<n$ e sia $k$ il numero totale di elementi in uno dei bucket 1..j. Per 2. abbiamo che ogni elemento $v$ in un bucket $i$ (con $i ≤ j$ ) è tale che $N/(j+1)≤N/(i+1)<v$ . Pertanto la somma $K$ di tutti gli elementi nei bucket da $1$ a $j$ è maggiore di $k×N/(J+1)$ . Ma questa somma$K$ è anche inferiore a$N$ quindi$k×N/(j+1) < K ≤ N$ e quindi $k/(j+1) < 1$ che ci dà$k<j+1$ o$k≤j$ .

4. $T$ soddisfa (*) cioè l'elemento$j$ -esimo di$T$ è tale che$T[j] ≤ N/j$

   Per 3. abbiamo che $T[j]$ , l' elemento $j$ -esimo di $T$ , proviene da un bucket $i$ con $i ≥ j$ quindi $T[j] ≤ N/i ≤ N/j$ .

5. Questo algoritmo richiede tempo lineare.

   Il calcolo di $N$ richiede tempo lineare. I bucket possono essere implementati con un elenco collegato con inserzione e iterazione $O(1)$ . Il ciclo nidificato viene eseguito tante volte quanti sono gli elementi (ovvero $n$ volte).

Sembra molto simile all'algoritmo ASort. Vedi questo articolo di Giesen et. al.:

https://www.inf.ethz.ch/personal/smilos/asort3.pdf

Sfortunatamente, il tempo di esecuzione non è del tutto lineare. L'articolo sopra dimostra che qualsiasi algoritmo randomizzato basato sul confronto che classifica elementi all'interno di n 2 / ν ( n ) ha un limite inferiore di n ∗ l o g ( ν ( n ) ) (assumendo ν ( n ) < n ).$n$$n^2/\nu(n)$$n*log (\nu(n))$$\nu(n) < n$

EDIT , in risposta ai chiarimenti nella domanda:

Quello che stai facendo è semplicemente un tipo di secchio . Tuttavia, l'algoritmo per l'ordinamento bucket non è lineare in questo caso. Il problema: devi sommare i numeri naturali e quindi eseguire la divisione su ciascuno di essi. Poiché i numeri hanno dimensioni illimitate, non è più un'operazione a tempo costante. Ci vorrà più tempo per eseguire più numeri che devi sommare.$N/V[i]$

Quanto ancora? La divisione dipende dal numero di cifre, quindi è , volte n operazioni di divisione. Probabilmente sembra familiare. :)$lg(n)$$n$

A quanto pare, la mia domanda è abbastanza irrilevante dopo tutto. In effetti, sto lavorando sulla macchina RAM con una misura del costo uniforme (ovvero, abbiamo registri i cui registri non sono necessariamente di dimensione costante ma possono memorizzare numeri interi di dimensione logaritmica nell'input al massimo e le operazioni su questi registri richiedono un tempo costante, tra cui almeno aggiunta). E in effetti, in questo modello, l'ordinamento di numeri interi (essenzialmente eseguendo un ordinamento radix) può essere fatto in tempo lineare. Ciò è spiegato nell'articolo del 1996 di Grandjean, Ordinamento, tempo lineare e problema di soddisfacibilità .

(This does not answer my question of whether there are well-studied notions of "almost sorting" a set of integers, but for them to be interesting one would probably need these weaker notions to be easier to enforce, i.e., work on a weaker model or somehow run in sublinear time. However, I'm currently not aware of a sense in which this would be the case.)