Menyortir menggunakan kotak hitam


20

Asumsikan kita ingin mengurutkan daftar dari bilangan real. Anggaplah kita diberi kotak hitam yang dapat mengurutkan bilangan real secara instan. Berapa banyak keuntungan yang bisa kita peroleh dengan menggunakan kotak hitam ini?n Snn

Misalnya, dapatkah kita mengurutkan angka hanya dengan panggilan ke kotak hitam? Algoritma terbaik yang saya temukan menggunakan panggilan ke kotak hitam. Tapi saya belum bisa memperbaikinya lebih lanjut. Berikut ini adalah algoritma saya yang mirip dengan merge-sort:nO(n)n

Pertama mempartisi daftar menjadi daftar dengan ukuran kira-kira . Kemudian gunakan panggilan ke kotak hitam untuk mengurutkan daftar ini. Akhirnya, gabungkan daftar yang diurutkan menggunakan kotak hitam sebagai berikut:S s1,s2,. . . ,sns1,s2,...,snnn

Letakkan elemen terkecil dari daftar di daftar baru , lalu panggil kotak hitam untuk mengurutkannya. Jumlah di (pertama dan elemen terkecil ) akan menjadi nomor terkecil di . Kita bisa meletakkannya di tempat pertama dari daftar keluaran. Dengan asumsi elemen telah dipilih dari , kita ganti dengan elemen terkecil kedua daftar semacam , dan lagi menjalankan kotak hitam di atasnya untuk menghitung anggota terkecil kedua . Kami melanjutkan sampai semua elemen diurutkan. Jumlah total panggilan kotak hitam untuk bagian ini adalahL [ 1 ] L S s j L [ 1 ] s j S n - LL[1]LS
sjL[1]sjS
nn. Oleh karena itu secara keseluruhan jumlah total panggilan akan .n

Di sisi lain, sepertinya kita harus dapat memperoleh batas bawah menggunakan batas bawah pada perbandingan jumlah yang diperlukan untuk menyortir sebagai berikut: Kita dapat menerapkan kotak hitam menggunakan perbandingan. Jika kita dapat menyelesaikan masalah dengan panggilan ke kotak hitam dan menggabungkan waktu linear, kita dapat mengurutkan bilangan real dengan perbandingan yang tidak mungkin.o(nlgn=12nlgnno(nlgn)o(n)no(nlgn)

Saya kira kita dapat membuktikan bahwa adalah batas bawah untuk jumlah panggilan ke kotak hitam, karena banyak perbandingan yang digunakan dalam kotak hitam akan dibagikan dan karenanya diceritakan dalam argumen kami.Ω(n)

UPDATE: Seperti yang disarankan oleh posting lain, sebuah juga dapat dicapai.nlgn


2
Tampaknya ada kesalahan ketik dalam komentar Anda. Apakah Anda bermaksud mengatakan: "tidak ada algoritma yang menggunakan kurang dari panggilan ke mesin dapat mengurutkanNbilangan real denganperbandingankurang dariNlgN"? Ps: Anda juga harus berhati-hati tentang fakta bahwaNlgNhanya terikat untuk algoritma pengurutan berbasis perbandingan.NNNlgNNlgN
Kaveh

8
Saya pikir kita bahkan bisa mendapatkan menggunakan jaringan sortir AKS. Jaringan mereka dapat dianggap sebagai contoh model Anda di mana kotak hitam dapat mengurutkan blok ukuran 2. Algoritma mereka menggunakanputaran, setiap putaran memanggil waktu 2-sorter. Satu "putaran" dari2-penyortir dapat dengan mudah disimulasikan dengan-sorters. O(nlogn)O ( n ) O ( n ) O ( O(logn)O(n)O(n)O(n) n
Vinayak Pathak

6
@VinayakPathak: Memecah data input menjadi potongan ukuran , dan kemudian mengurutkan potongan menggunakan jaringan AKS, setelah mengganti masing-masing pembanding dengan -sorter. 2NN/2N
Jeffε

1
@ Jɛ ff E: Ya, bagus, itu jelas terlihat lebih sederhana daripada konstruksi saya.
Vinayak Pathak

1
@ Jɛ ff E, komentar Anda bisa menjadi jawaban. :)
Kaveh

Jawaban:


15

Dimungkinkan untuk menyortir dengan panggilan ke kotak hitam dan tidak ada perbandingan.O(nlogn)

Pertama, pertimbangkan masalah pembagian berimbang berikut: diberikan elemen A [ 1 .. m ] (di mana mA[1..m]), bagi mereka menjadi dua kelompok, ukuran terkecil setidaknya sekitarm/4, sehingga semua elemen dalam kelompok pertama lebih kecil dari semua elemen dalam kelompok kedua. Ini dapat dilakukan denganO(m/nmnm/4panggilan ke kotak hitam. (Saya akan jelaskan nanti.) Kemudian gunakan quicksort dengan algoritma partisi ini:O(m/n)

def qsort(A[1..m]):
   if m < sqrt(n): sort A with one call to the black box
   else:
     Partition A[1..m] into two groups as described above.
     Recursively qsort the first group.
     Recursively qsort the second group.

Dengan asumsi setiap langkah partisi membutuhkan panggilan ke kotak hitam, algoritma di atas, diberi inputA[1 ..n], akan menghasilkanO(O(m/n)A[1..n]memanggil ke kotak hitam, karena pohon rekursi memiliki kedalamanO(logn)dan setiap tingkat pohon memiliki totalO(n/O(nlogn)O(logn)panggilan ke kotak hitam.O(n/n)=O(n)

Lakukan langkah pemartisian sebagai berikut:

def partition(A[1..m]):  (where sqrt(n) <= m <= n)
   Divide A into m/sqrt(n) groups of size sqrt(n) each.
   Sort each group with one call to the black box per group.
   Sort the medians of the groups with one call to the black box.
   (Note the number of groups is less than sqrt(n), because m <= n.)
   Let X be the median of the medians.
   Partition all m elements around X, using the black box as follows:
      For each group G, let Y be its median:
        Call the black box once on (G - {Y}) union {X}.
        (This gives enough information to order all elts w.r.t. X.)

Pada langkah terakhir dari partisi algoritme (): "Partisi semua elemen m di sekitar X", tidakkah ini akan menggunakan perbandingan tambahan m?
Vinayak Pathak

2
Lihat garis hanya mengikuti algoritma, ini menjelaskan cara melakukan langkah itu. Saya akan mengeditnya untuk membuatnya lebih jelas.
Neal Young

24

Saya pikir pertanyaan Anda telah dialamatkan dalam makalah Beigel dan Gill " Menyortir n objek menggunakan k-sorter " dari tahun 1990 dan abstrak makalah ini mengatakan semuanya:

K-sorter adalah perangkat yang mengurutkan objek k dalam satuan waktu. Kompleksitas suatu algoritma yang menggunakan penyortir-k didefinisikan sebagai jumlah aplikasi penyusun-k. Dalam ukuran ini, kompleksitas pengurutan n objek adalah antara dan4nlognnlognklogk , hingga istilah orde pertama dalam n dan k.4nlognklogk


Terima kasih. Saya tidak dapat menemukan kertas itu. Bisakah Anda memberikan tautan ke kertas atau buktinya?
AmeerJ


Juga pada citeseerx .
Kaveh

8
Perhatikan bahwa ketika , Beigel dan Gill terikat adalahΘ(k=n. Θ(n)
Jeffε

12

Hal ini dimungkinkan untuk memilah obliviously dengan panggilan ke kotak hitam, masing-masing diterapkan pada subarray yang berdekatan dari input asli. Algoritma tidak pernah menyentuh data input kecuali melalui panggilan kotak hitam. Secara khusus, urutan yang sama dari panggilan kotak hitam hanya fungsi darin, bukan data input aktual (karenanya "tidak menyadari").O(nlogn)n

Berikut ini adalah sketsa dari algoritma yang lebih sederhana, yang menggunakan kotak hitam yang mengurutkan subarrays dari ukuran bukan hanya k . Jumlah total panggilan ke kotak hitam kira-kira2(n/k)2. Untuk kesederhanaan notasi, asumsikan bahwakadalah genap dan2n/kadalah bilangan bulat ganjil.n2(n/k)2k2n/k

BlockBubbleSort(X[0..n-1], k):
   m = floor(n/k)
   for i = 1 to m
      for j = 0 to m-1
          BlackBoxSort(X[j*k .. (j+1)*k-1])
      for j = 0 to m-1
          BlackBoxSort(X[j*k + k/2 .. (j+1)*k + k/2 - 1])

Berikut adalah diagram algoritma untuk dan k = 4 . Data bergerak dari kiri ke kanan; setiap kotak adalah k -sorter.n=18k=4k

masukkan deskripsi gambar di sini

k/2k

O((n/k)2)O((n/k)log2(n/k))=O(nlog2n)O((n/k)log(n/k))=O(nlogn)


Ω(n lg(n))

2
O(n)

+1 untuk gambar yang bagus itu! Saya mungkin salah tetapi menurut saya itu tidak sepenuhnya benar (koreksi saya jika saya salah). Dengan asumsi output dalam urutan menaik, jika elemen terkecil ada di posisi terakhir, maka tidak ada "jalur" baginya untuk "bergerak" ke posisi pertama. Mengubah "untuk i = 1 ke m" menjadi "untuk i = 1 ke m +1" tampaknya memperbaiki hal ini, meskipun mungkin memperkenalkan beberapa overhead yang tidak perlu.
George

@ George Ups, kau benar; Saya perlu satu lapisan lagi!
Jeffε
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.