Bilangan bulat "Almost sorting" dalam waktu linier

Saya tertarik untuk menyortir array nilai integer positif $L = v_1, \ldots, v_n$ dalam waktu linier (dalam model RAM dengan ukuran biaya seragam, yaitu, bilangan bulat dapat memiliki ukuran logaritmik tetapi operasi aritmatika pada mereka diasumsikan ambil satuan waktu). Tentu saja, ini tidak mungkin dengan algoritma pengurutan berbasis perbandingan, jadi saya tertarik untuk menghitung semacam "perkiraan", yaitu, menghitung beberapa permutasi $v_{\sigma(1)}, \ldots, v_{\sigma(n)}$ dari $L$yang tidak benar-benar diurutkan secara umum tetapi "perkiraan yang baik" dari versi $L$ diurutkan . Saya akan berasumsi bahwa kita sedang mengurutkan bilangan bulat dalam urutan menurun karena itu membuat sekuelnya sedikit lebih menyenangkan untuk dinyatakan, tetapi tentu saja orang bisa mengutarakan masalahnya dengan cara sebaliknya.

Salah satu kriteria yang mungkin untuk jenis perkiraan adalah sebagai berikut (*): membiarkan $N$ menjadi $\sum_i v_i$ , untuk setiap $1 \leq i \leq n$ , kami mengharuskan $v_{\sigma(i)} \leq N/i$ (yaitu, "kuasi-diurutkan" "daftar dibatasi dari atas oleh fungsi penurunan $i \mapsto N/i$ ). Mudah untuk melihat bahwa jenis yang sebenarnya memenuhi ini: $v_{\sigma(2)}$ harus tidak lebih besar dari $v_{\sigma(1)}$jadi paling banyak $(v_{\sigma(1)} + v_{\sigma(2)})/2$ yang $\leq N/2$ , dan secara umum $v_{\sigma(i)}$ harus tidak lebih besar dari $(\sum_{j \leq i} v_{\sigma(i)})/i$ yang $\leq N/i$ .

Misalnya, persyaratan (*) dapat dicapai dengan algoritma di bawah ini (disarankan oleh @Louis). Pertanyaanku adalah: Apakah ada pekerjaan yang ada pada tugas ini dari "hampir menyortir" bilangan bulat dalam waktu linier, dengan memaksakan beberapa persyaratan seperti (*) yang jenis nyata akan memuaskan? Apakah algoritme di bawah ini, atau beberapa varian darinya, memiliki nama mapan?

Sunting: memperbaiki algoritme dan menambahkan lebih banyak penjelasan

Algoritma:

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

Algoritma ini berfungsi sebagaimana dimaksud untuk alasan berikut:

1. Jika elemen $v$ ada di dalam ember $j$ maka $v ≤ N/j$ .

   $v$ dimasukkan ke dalam ember$j=\min(N/v,n)$ , dengan demikian$j ≤ \lfloor N/v\rfloor ≤ N/v$

2. Jika elemen $v$ ada di dalam ember $j$ maka $N/(j+1) < v$ atau $j=n$ .

   $v$ dimasukkan ke dalam ember$j=\min(N/v,n)$ , dengan demikian$j = \lfloor N/v \rfloor$ atau$j=n$ . Dalam kasus pertama$j=\lfloor N/v\rfloor$ yang berarti$j ≤ N/v < j+1$ dan dengan demikian$N/(j+1) < v$ .

3. Untuk $j<n$ , ada, paling banyak, elemen $j$ dalam bucket dari 1 hingga $j$ .

   Misalkan $j<n$ dan misalkan $k$ adalah jumlah total elemen dalam salah satu ember 1..j. Dengan 2. kita mengetahui bahwa setiap elemen $v$ dalam ember $i$ (dengan $i ≤ j$ ) sedemikian rupa sehingga $N/(j+1)≤N/(i+1)<v$ . Oleh karena itu jumlah $K$ dari semua elemen dalam ember dari $1$ hingga $j$ lebih besar dari $k×N/(J+1)$ . Tetapi jumlah$K$ ini juga kurang dari$N$ sehingga$k×N/(j+1) < K ≤ N$ dan dengan demikian $k/(j+1) < 1$ yang memberi kita$k<j+1$ atau$k≤j$ .

4. $T$ memenuhi (*) yaituelemen ke-$j$ dari$T$ sedemikian rupa sehingga$T[j] ≤ N/j$

   Dengan 3. kita memiliki $T[j]$ , elemen ke- $j$ dari $T$ , berasal dari ember $i$ dengan $i ≥ j$ oleh karena itu $T[j] ≤ N/i ≤ N/j$ .

5. Algoritma ini membutuhkan waktu linier.

   Perhitungan $N$ membutuhkan waktu linier. Bucket dapat diimplementasikan dengan daftar tertaut yang memiliki penyisipan dan iterasi $O(1)$ . Loop bersarang berjalan sebanyak yang ada elemen (yaitu $n$ kali).

Ini terdengar sangat mirip dengan algoritma ASort. Lihat artikel ini oleh Giesen et. Al.:

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

$n$$n^2/\nu(n)$$n*log (\nu(n))$$\nu(n) < n$

EDIT , sebagai tanggapan atas klarifikasi dalam pertanyaan:

$N/V[i]$

$lg(n)$$n$

Ternyata, pertanyaan saya agak tidak relevan. Memang, saya bekerja pada mesin RAM dengan ukuran biaya yang seragam (yaitu, kami memiliki register yang registernya tidak harus berukuran konstan tetapi dapat menyimpan bilangan bulat ukuran logaritmik dalam input paling banyak, dan operasi pada register ini membutuhkan waktu konstan, termasuk setidaknya penambahan). Dan pada kenyataannya, dalam model ini, penyortiran bilangan bulat (dengan dasarnya melakukan semacam radix) dapat dilakukan dalam waktu linier. Ini dijelaskan dalam makalah 1996 oleh Grandjean, Sorting, waktu linier dan masalah kepuasan .

(Ini tidak menjawab pertanyaan saya tentang apakah ada gagasan yang dipelajari dengan baik tentang "hampir menyortir" satu set bilangan bulat, tetapi agar mereka menjadi menarik orang mungkin akan membutuhkan gagasan yang lebih lemah ini untuk lebih mudah ditegakkan, yaitu, bekerja pada yang lebih lemah. model atau entah bagaimana berjalan dalam waktu sublinear. Namun, saya saat ini tidak mengetahui perasaan di mana ini akan terjadi.)