Kenapa yang minimalis, contoh quicksort Haskell bukan quicksort yang “benar”?

Situs web Haskell memperkenalkan fungsi quicksort 5 baris yang sangat menarik , seperti yang terlihat di bawah ini.

quicksort [] = []
quicksort (p:xs) = (quicksort lesser) ++ [p] ++ (quicksort greater)
    where
        lesser = filter (< p) xs
        greater = filter (>= p) xs

Mereka juga menyertakan "True quicksort in C" .

// To sort array a[] of size n: qsort(a,0,n-1)

void qsort(int a[], int lo, int hi) 
{
  int h, l, p, t;

  if (lo < hi) {
    l = lo;
    h = hi;
    p = a[hi];

    do {
      while ((l < h) && (a[l] <= p)) 
          l = l+1;
      while ((h > l) && (a[h] >= p))
          h = h-1;
      if (l < h) {
          t = a[l];
          a[l] = a[h];
          a[h] = t;
      }
    } while (l < h);

    a[hi] = a[l];
    a[l] = p;

    qsort( a, lo, l-1 );
    qsort( a, l+1, hi );
  }
}

Link di bawah versi C mengarahkan ke halaman yang menyatakan 'Quicksort yang dikutip dalam Pendahuluan bukanlah quicksort "sebenarnya" dan tidak menskalakan untuk daftar yang lebih panjang seperti yang dilakukan kode c.'

Mengapa fungsi Haskell di atas bukan quicksort yang sebenarnya? Bagaimana cara gagal menskalakan daftar yang lebih panjang?

Quicksort yang sebenarnya memiliki dua aspek yang indah:

1. Bagilah dan taklukkan: pecahkan masalah menjadi dua masalah kecil.
2. Partisi elemen di tempat.

Contoh singkat Haskell menunjukkan (1), tetapi tidak (2). Bagaimana (2) dilakukan mungkin tidak jelas jika Anda belum mengetahui tekniknya!

Quicksort inplace yang sebenarnya di Haskell:

import qualified Data.Vector.Generic as V 
import qualified Data.Vector.Generic.Mutable as M 

qsort :: (V.Vector v a, Ord a) => v a -> v a
qsort = V.modify go where
    go xs | M.length xs < 2 = return ()
          | otherwise = do
            p <- M.read xs (M.length xs `div` 2)
            j <- M.unstablePartition (< p) xs
            let (l, pr) = M.splitAt j xs 
            k <- M.unstablePartition (== p) pr
            go l; go $ M.drop k pr

Berikut ini adalah transliterasi dari kode C quicksort "benar" ke Haskell. Persiapkan dirimu.

import Control.Monad
import Data.Array.IO
import Data.IORef

qsort :: IOUArray Int Int -> Int -> Int -> IO ()
qsort a lo hi = do
  (h,l,p,t) <- liftM4 (,,,) z z z z

  when (lo < hi) $ do
    l .= lo
    h .= hi
    p .=. (a!hi)

    doWhile (get l .< get h) $ do
      while ((get l .< get h) .&& ((a.!l) .<= get p)) $ do
        modifyIORef l succ
      while ((get h .> get l) .&& ((a.!h) .>= get p)) $ do
        modifyIORef h pred
      b <- get l .< get h
      when b $ do
        t .=. (a.!l)
        lVal <- get l
        hVal <- get h
        writeArray a lVal =<< a!hVal
        writeArray a hVal =<< get t

    lVal <- get l
    writeArray a hi =<< a!lVal
    writeArray a lVal =<< get p

    hi' <- fmap pred (get l)
    qsort a lo hi'
    lo' <- fmap succ (get l)
    qsort a lo' hi

Itu menyenangkan, bukan? Saya benar-benar memotong ini besar letdi awal, serta wheredi akhir fungsi, mendefinisikan semua pembantu untuk membuat kode sebelumnya agak cantik.

  let z :: IO (IORef Int)
      z = newIORef 0
      (.=) = writeIORef
      ref .=. action = do v <- action; ref .= v
      (!) = readArray
      (.!) a ref = readArray a =<< get ref
      get = readIORef
      (.<) = liftM2 (<)
      (.>) = liftM2 (>)
      (.<=) = liftM2 (<=)
      (.>=) = liftM2 (>=)
      (.&&) = liftM2 (&&)
  -- ...
  where doWhile cond foo = do
          foo
          b <- cond
          when b $ doWhile cond foo
        while cond foo = do
          b <- cond
          when b $ foo >> while cond foo

Dan di sini, tes bodoh untuk melihat apakah itu berhasil.

main = do
    a <- (newListArray (0,9) [10,9..1]) :: IO (IOUArray Int Int)
    printArr a
    putStrLn "Sorting..."
    qsort a 0 9
    putStrLn "Sorted."
    printArr a
  where printArr a = mapM_ (\x -> print =<< readArray a x) [0..9]

Saya tidak terlalu sering menulis kode imperatif di Haskell, jadi saya yakin ada banyak cara untuk membersihkan kode ini.

Terus?

Anda akan melihat bahwa kode di atas sangat, sangat panjang. Inti dari itu adalah sepanjang kode C, meskipun setiap baris seringkali sedikit lebih bertele-tele. Ini karena C diam-diam melakukan banyak hal buruk yang mungkin Anda anggap remeh. Misalnya a[l] = a[h];,. Ini mengakses variabel yang bisa berubah ldan h, lalu mengakses array yang bisa berubah a, dan kemudian mengubah array yang bisa berubah a. Mutasi suci, batman! Di Haskell, mutasi dan mengakses variabel yang bisa berubah itu eksplisit. Qsort "palsu" menarik karena berbagai alasan, tetapi yang paling utama adalah tidak menggunakan mutasi; pembatasan yang diberlakukan sendiri ini membuatnya lebih mudah untuk dipahami dalam sekejap.

Menurut pendapat saya, mengatakan bahwa ini "bukan quicksort yang sebenarnya" terlalu melebih-lebihkan kasusnya. Saya pikir ini adalah implementasi yang valid dari algoritma Quicksort , hanya saja bukan yang sangat efisien.

Saya pikir kasus yang coba dibuat argumen ini adalah alasan mengapa quicksort umum digunakan adalah karena itu ada di tempat dan sebagai hasilnya cukup ramah-cache. Karena Anda tidak memiliki manfaat tersebut dengan daftar Haskell, alasan utamanya hilang, dan Anda mungkin juga menggunakan jenis gabungan, yang menjamin O (n log n) , sedangkan dengan quicksort Anda harus menggunakan pengacakan atau rumit skema partisi untuk menghindari run time O (n ² ) dalam kasus terburuk.

Berkat evaluasi malas, program Haskell tidak (hampir tidak bisa ) melakukan apa yang terlihat seperti yang dilakukannya.

Pertimbangkan program ini:

main = putStrLn (show (quicksort [8, 6, 7, 5, 3, 0, 9]))

Dalam bahasa yang bersemangat, pertama quicksortakan lari, lalu show, lalu putStrLn. Argumen fungsi dihitung sebelum fungsi tersebut mulai berjalan.

Di Haskell, justru sebaliknya. Fungsi tersebut mulai berjalan lebih dulu. Argumen hanya dihitung saat fungsi benar-benar menggunakannya. Dan argumen gabungan, seperti daftar, dihitung satu per satu, karena setiap bagian digunakan.

Jadi hal pertama yang terjadi dalam program ini adalah yang putStrLnmulai berjalan.

Implementasi GHC dari putStrLn bekerja dengan menyalin karakter dari argumen String ke dalam buffer keluaran. Tapi saat memasuki loop ini, showbelum berjalan. Oleh karena itu, saat akan menyalin karakter pertama dari string, Haskell mengevaluasi pecahan dari panggilan showdan yang quicksortdiperlukan untuk menghitung karakter itu . Kemudian putStrLnberalih ke karakter berikutnya. Jadi eksekusi ketiga functions- putStrLn, showdan quicksort- disisipkan. quicksortdieksekusi secara bertahap, meninggalkan grafik halangan yang tidak dievaluasi untuk mengingat di mana ia tinggalkan.

Sekarang ini sangat berbeda dari apa yang mungkin Anda harapkan jika Anda terbiasa dengan, Anda tahu, bahasa pemrograman lain yang pernah ada. Tidak mudah untuk memvisualisasikan bagaimana quicksortsebenarnya berperilaku di Haskell dalam hal akses memori atau bahkan urutan perbandingan. Jika Anda hanya dapat mengamati perilakunya, dan bukan kode sumbernya, Anda tidak akan mengenali apa yang dilakukannya sebagai quicksort .

Misalnya, versi C dari quicksort mempartisi semua data sebelum panggilan rekursif pertama. Dalam versi Haskell, elemen pertama dari hasil akan dihitung (dan bahkan dapat muncul di layar Anda) sebelum partisi pertama selesai dijalankan — bahkan sebelum pekerjaan apa pun diselesaikan greater.

PS Kode Haskell akan lebih seperti quicksort jika ia melakukan jumlah perbandingan yang sama dengan quicksort; kode seperti yang tertulis melakukan perbandingan dua kali lebih banyak karena lesserdan greaterditentukan untuk dihitung secara independen, melakukan dua pemindaian linier melalui daftar. Tentu saja pada prinsipnya mungkin bagi compiler untuk menjadi cukup pintar untuk menghilangkan perbandingan ekstra; atau kode dapat diubah untuk digunakan Data.List.partition.

PPS Contoh klasik dari algoritma Haskell ternyata tidak berperilaku seperti yang Anda harapkan adalah saringan Eratosthenes untuk menghitung bilangan prima.

Saya percaya bahwa alasan kebanyakan orang mengatakan bahwa Haskell Quicksort yang cantik bukanlah Quicksort yang "benar" adalah kenyataan bahwa ia tidak ada pada tempatnya - jelas, tidak mungkin ketika menggunakan tipe data yang tidak dapat diubah. Tetapi ada juga keberatan bahwa ini tidak "cepat": sebagian karena ++ mahal, dan juga karena ada kebocoran spasi - Anda tetap berpegang pada daftar masukan saat melakukan panggilan rekursif pada elemen yang lebih rendah, dan dalam beberapa kasus - misalnya ketika daftar menurun - ini menghasilkan penggunaan ruang kuadrat. (Anda mungkin mengatakan bahwa membuatnya berjalan dalam ruang linier adalah cara terdekat yang bisa Anda dapatkan "di tempat" menggunakan data yang tidak dapat diubah.) Ada solusi yang tepat untuk kedua masalah tersebut, dengan menggunakan parameter yang terakumulasi, tupling, dan fusi; lihat S7.6.1 dari Richard Bird '

Ini bukanlah gagasan mutasi elemen di tempat dalam pengaturan fungsional murni. Metode alternatif di utas ini dengan array yang bisa berubah kehilangan semangat kemurnian.

Setidaknya ada dua langkah untuk mengoptimalkan versi dasar (yang merupakan versi paling ekspresif) dari penyortiran cepat.

1. Optimalkan penggabungan (++), yang merupakan operasi linier, dengan akumulator:

   qsort xs = qsort' xs []
   
   qsort' [] r = r
   qsort' [x] r = x:r
   qsort' (x:xs) r = qpart xs [] [] r where
       qpart [] as bs r = qsort' as (x:qsort' bs r)
       qpart (x':xs') as bs r | x' <= x = qpart xs' (x':as) bs r
                              | x' >  x = qpart xs' as (x':bs) r

2. Optimalkan ke pengurutan cepat terner (partisi 3 arah, disebutkan oleh Bentley dan Sedgewick), untuk menangani elemen duplikat:

   tsort :: (Ord a) => [a] -> [a]
   tsort [] = []
   tsort (x:xs) = tsort [a | a<-xs, a<x] ++ x:[b | b<-xs, b==x] ++ tsort [c | c<-xs, c>x]

3. Gabungkan 2 dan 3, lihat buku Richard Bird:

   psort xs = concat $ pass xs []
   
   pass [] xss = xss
   pass (x:xs) xss = step xs [] [x] [] xss where
       step [] as bs cs xss = pass as (bs:pass cs xss)
       step (x':xs') as bs cs xss | x' <  x = step xs' (x':as) bs cs xss
                                  | x' == x = step xs' as (x':bs) cs xss
                                  | x' >  x = step xs' as bs (x':cs) xss

Atau sebagai alternatif jika elemen yang diduplikasi bukan mayoritas:

    tqsort xs = tqsort' xs []

    tqsort' []     r = r
    tqsort' (x:xs) r = qpart xs [] [x] [] r where
        qpart [] as bs cs r = tqsort' as (bs ++ tqsort' cs r)
        qpart (x':xs') as bs cs r | x' <  x = qpart xs' (x':as) bs cs r
                                  | x' == x = qpart xs' as (x':bs) cs r
                                  | x' >  x = qpart xs' as bs (x':cs) r

Sayangnya, median-of-three tidak dapat diimplementasikan dengan efek yang sama, misalnya:

    qsort [] = []
    qsort [x] = [x]
    qsort [x, y] = [min x y, max x y]
    qsort (x:y:z:rest) = qsort (filter (< m) (s:rest)) ++ [m] ++ qsort (filter (>= m) (l:rest)) where
        xs = [x, y, z]
        [s, m, l] = [minimum xs, median xs, maximum xs] 

karena kinerjanya masih buruk untuk 4 kasus berikut:

1. [1, 2, 3, 4, ...., n]

2. [n, n-1, n-2, ..., 1]

3. [m-1, m-2, ... 3, 2, 1, m + 1, m + 2, ..., n]

4. [n, 1, n-1, 2, ...]

Semua 4 kasus ini ditangani dengan baik dengan pendekatan median-of-three yang penting.

Sebenarnya, algoritme pengurutan yang paling cocok untuk pengaturan yang murni berfungsi adalah jenis gabungan, tetapi bukan pengurutan cepat.

Untuk detailnya, silakan kunjungi tulisan saya yang sedang berlangsung di: https://sites.google.com/site/algoxy/dcsort

Tidak ada definisi yang jelas tentang apa itu quicksort dan apa yang bukan quicksort yang sebenarnya.

Mereka menyebutnya bukan quicksort yang sebenarnya, karena tidak diurutkan di tempat:

Quicksort benar dalam tipe C di tempat

Karena mengambil elemen pertama dari daftar menghasilkan waktu proses yang sangat buruk. Gunakan median dari 3: pertama, tengah, terakhir.

Minta siapa saja untuk menulis quicksort di Haskell, dan pada dasarnya Anda akan mendapatkan program yang sama - ini jelas quicksort. Berikut beberapa kelebihan dan kekurangannya:

Pro: Ini meningkatkan quicksort "benar" dengan menjadi stabil, yaitu mempertahankan urutan urutan di antara elemen yang sama.

Pro: Adalah sepele untuk menggeneralisasi menjadi tiga arah split (<=>), yang menghindari perilaku kuadrat karena beberapa nilai yang terjadi O (n) kali.

Pro: Lebih mudah dibaca - bahkan jika harus menyertakan definisi filter.

Kontra: Menggunakan lebih banyak memori.

Kontra: Sangat mahal untuk menggeneralisasi pilihan pivot dengan pengambilan sampel lebih lanjut, yang dapat menghindari perilaku kuadrat pada urutan entropi rendah tertentu.