"Fast sortieren" von ganzen Zahlen in linearer Zeit

Ich bin daran interessiert, ein Array positiver ganzzahliger Werte in linearer Zeit zu sortieren (im RAM-Modell mit einheitlichem Kostenmaß, dh ganze Zahlen können bis zu logarithmischer Größe haben, aber es wird angenommen, dass arithmetische Operationen auf sie angewendet werden Zeiteinheit). Natürlich ist dies mit vergleichsbasierten Sortieralgorithmen nicht möglich, daher bin ich daran interessiert, eine "ungefähre" Sortierung zu berechnen, dh eine Permutation von von , die in der Regel sortiert , sondern eine „gute Annäherung“ der sortierten Version nicht wirklich . Ich gehe davon aus, dass wir die ganzen Zahlen in absteigender Reihenfolge sortieren, da dies die Aussage der Fortsetzung ein wenig angenehmer macht, aber man könnte das Problem natürlich auch andersherum formulieren.$L = v_1, \ldots, v_n$$v_{\sigma(1)}, \ldots, v_{\sigma(n)}$$L$$L$

Ein mögliches Kriterium für eine ungefähre sortieren ist die folgende (*): lassen sein , für jeden , verlangen wir , dass (dh Die "quasi-sortierte" Liste wird von oben durch die abnehmende Funktion ) begrenzt. Es ist leicht zu erkennen, dass die tatsächliche Sortierung dies erfüllt: darf nicht größer als daher ist es höchstens ist und im Allgemeinen darf nicht größer sein als ist$N$$\sum_i v_i$$1 \leq i \leq n$$v_{\sigma(i)} \leq N/i$$i \mapsto N/i$$v_{\sigma(2)}$$v_{\sigma(1)}$$(v_{\sigma(1)} + v_{\sigma(2)})/2$$\leq N/2$$v_{\sigma(i)}$$(\sum_{j \leq i} v_{\sigma(i)})/i$$\leq N/i$.

Zum Beispiel kann Anforderung (*) durch den folgenden Algorithmus erreicht werden (vorgeschlagen von @Louis). Meine Frage ist: Gibt es eine Arbeit zu dieser Aufgabe, ganze Zahlen in linearer Zeit "fast zu sortieren", indem eine Bedingung wie (*) auferlegt wird, die die reale Sortierung erfüllen würde? Hat der unten stehende Algorithmus oder eine Variante davon einen festgelegten Namen?

Bearbeiten: Der Algorithmus wurde korrigiert und es wurden weitere Erklärungen hinzugefügt

Algorithmus:

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
| +
+

Dieser Algorithmus funktioniert aus folgenden Gründen wie beabsichtigt:

1. Befindet sich ein Element im Bucket dann ist . $v$$j$$v ≤ N/j$

   $v$ wird in den Eimer gegeben , also$j=\min(N/v,n)$$j ≤ \lfloor N/v\rfloor ≤ N/v$

2. Befindet sich ein Element im Bucket dann ist entweder oder . $v$$j$$N/(j+1) < v$$j=n$

   $v$j = min ( N / v , n ) , j = ⌊ N / v ⌋ j = n j = ⌊ N / v ⌋ j ≤ N / v < j + 1 N / ( j + 1 ) < v wird in den Eimer gestellt , also oder . Im ersten Fall ist was bedeutet, dass und somit .$j=\min(N/v,n)$$j = \lfloor N/v \rfloor$$j=n$$j=\lfloor N/v\rfloor$$j ≤ N/v < j+1$$N/(j+1) < v$

3. Für gibt es höchstens Elemente in den Buckets von 1 bis .$j<n$$j$$j$

   Sei und sei die Gesamtzahl der Elemente in einem der Buckets 1..j. Mit 2. haben wir, dass jedes Element in einem Bucket (mit ) so ist, dass . Daher ist die Summe aller Elemente in den Buckets von bis größer als . Aber diese Summe ist auch weniger als so und somit , die uns gibt oder .$j<n$$k$V i i ≤ j N / ( j + 1 ) ≤ N / ( i + 1 ) < v K 1 j k × N / ( J + 1 ) K N k × N / ( j + 1 ) < K ≤ N k / ( j + 1 ) <$v$$i$$i ≤ j$$N/(j+1)≤N/(i+1)<v$$K$$1$$j$$k×N/(J+1)$$K$$N$$k×N/(j+1) < K ≤ N$$k/(j+1) < 1$$k<j+1$$k≤j$

4. $T$ erfüllt (*), dh das te Element von ist so, dass$j$$T$$T[j] ≤ N/j$

   Nach 3. haben wir, dass , das te Element von , aus einem Bucket mit also .$T[j]$$j$$T$$i$$i ≥ j$$T[j] ≤ N/i ≤ N/j$

5. Dieser Algorithmus benötigt eine lineare Zeit.

   Die Berechnung von dauert linear. Buckets können mit einer verknüpften Liste implementiert werden, die -Einfügung und -Iteration aufweist. Die verschachtelte Schleife wird so oft ausgeführt, wie Elemente vorhanden sind (dh mal).$N$$O(1)$$n$

Das klingt sehr nach dem ASort-Algorithmus. Siehe diesen Artikel von Giesen et. al .:

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

Leider ist die Laufzeit nicht ganz linear. Der obige Artikel beweist, dass jeder vergleichsbasierte randomisierte Algorithmus, der Elemente innerhalb von einstuft, eine Untergrenze von (unter der Annahme von ).n 2 / ν ( n ) n * l o g ( ν ( n ) ) ν ( n ) < $n$$n^2/\nu(n)$$n*log (\nu(n))$$\nu(n) < n$

BEARBEITEN , als Antwort auf die Klarstellungen in der Frage:

Was Sie tun, ist einfach eine Eimersorte . Der Algorithmus für die Bucket-Sortierung ist in diesem Fall jedoch nicht linear. Das Problem: Sie müssen die natürlichen Zahlen summieren und dann für jede eine Division durchführen. Da die Anzahl unbegrenzt groß ist, ist keine zeitlich konstante Operation mehr. Je mehr Zahlen Sie summieren müssen, desto länger dauert die Ausführung.$N/V[i]$

Wie lange noch? Die Division hängt von der Anzahl der Stellen ab, also ist es mal Divisionsoperationen. Das kommt mir wahrscheinlich bekannt vor. :)$lg(n)$$n$

Wie sich herausstellt, ist meine Frage doch ziemlich irrelevant. In der Tat arbeite ich an der RAM-Maschine mit einem einheitlichen Kostenmaß (dh, wir haben Register, deren Register nicht notwendigerweise von konstanter Größe sind, die aber höchstens Ganzzahlen logarithmischer Größe in der Eingabe speichern können, und Operationen an diesen Registern dauern konstant, einschließlich mindestens zusätzlich). Tatsächlich können in diesem Modell ganze Zahlen (durch im Wesentlichen Ausführen einer Radix-Sortierung) in linearer Zeit sortiert werden. Dies wird in der Arbeit von 1996 durch Grandjean, Sortieren, lineare Zeit und das Erfüllbarkeitsproblem erläutert .

(Dies beantwortet nicht meine Frage, ob es gut untersuchte Begriffe gibt, eine Menge von ganzen Zahlen "fast zu sortieren", aber damit sie interessant sind, müssten diese schwächeren Begriffe wahrscheinlich leichter durchgesetzt werden, dh an einer schwächeren gearbeitet werden Modell oder läuft irgendwie in sublinearer Zeit. Allerdings ist mir derzeit nicht bewusst, in welchem ​​Sinne dies der Fall wäre.)