为什么极简主义，例如 Haskell 快速排序不是“真正的”快速排序？

Question

Haskell 的网站介绍了一个非常吸引人的 5 行代码 quicksort function，如下所示。

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

它们还包括一个“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 );
  }
}

C 版本下方的链接指向一个页面，该页面声明“简介中引用的快速排序不是“真正的”快速排序，并且不能像 c 代码那样针对更长的列表进行缩放。'

为什么上面的 Haskell 函数不是真正的快速排序？它如何无法扩展更长的列表？

Answer 1

真正的快速排序有两个美妙的方面：

1. 分而治之：将问题分解为两个较小的问题。
2. 就地对元素进行分区。

简短的 Haskell 示例演示了 (1)，但没有演示 (2)。如果您还不了解该技术，如何完成 (2) 可能并不明显！

Answer 2

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

Answer 3

这里是“真正的”快速排序 C 代码到 Haskell 的音译。振作起来。

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

这很有趣，不是吗？实际上，我在开头剪掉了这个大的let，以及函数末尾的where，定义了所有的帮助器，以使前面的代码更漂亮。

  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

在这里，一个愚蠢的测试，看看它是否有效。

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]

我不经常在 Haskell 中编写命令式代码，所以我确信有很多方法可以清理这些代码。

那又怎样？

你会注意到上面的代码非常非常长。它的核心大约与 C 代码一样长，尽管每一行通常都比较冗长。这是因为 C 暗中做了很多你可能认为理所当然的讨厌的事情。例如，a[l] = a[h];。这会访问可变变量l 和h，然后访问可变数组a，然后对可变数组a 进行变异。神圣的突变，蝙蝠侠！在 Haskell 中，变异和访问可变变量是明确的。 “假” qsort 具有多种吸引力，但其中最主要的是它不使用突变；这种自我强加的限制让人一目了然。

Answer 4

在我看来，说它“不是真正的快速排序”夸大了情况。我认为这是Quicksort algorithm 的有效实现，只是不是特别有效。

Answer 5

我认为这个论点试图说明的情况是，快速排序之所以常用，是因为它是就地的，因此对缓存非常友好。由于 Haskell 列表没有这些好处，它的主要存在理由已经消失，你不妨使用合并排序，它保证 O(n log n)，而使用快速排序你要么必须使用随机化或复杂的分区方案，以避免在最坏的情况下 O(n²) 运行时间。

Answer 6

由于惰性求值，Haskell 程序不能（几乎不能）做它看起来做的事情。

考虑这个程序：

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

在热切的语言中，首先运行quicksort，然后运行show，然后运行putStrLn。在函数开始运行之前计算函数的参数。

在 Haskell 中，情况正好相反。该函数首先开始运行。只有在函数实际使用它们时才会计算参数。复合参数，如列表，每次计算一个，因为它的每一部分都被使用。

所以这个程序中发生的第一件事是putStrLn开始运行。

GHC's implementation of putStrLn 通过将参数 String 的字符复制到输出缓冲区来工作。但是当它进入这个循环时，show 还没有运行。因此，当它从字符串中复制第一个字符时，Haskell 会计算计算 该字符所需的 show 和 quicksort 调用的分数。然后putStrLn 移动到下一个字符。因此，所有三个函数（putStrLn、show 和 quicksort）的执行都是交错的。 quicksort 以增量方式执行，留下一个 unevaluated thunks 的图表，因为它会记住它停止的位置。

现在，如果您熟悉任何其他编程语言，这与您所期望的完全不同。很难想象quicksort 在内存访问甚至比较顺序方面在 Haskell 中的实际行为。如果您只能观察行为，而不是源代码，您将无法识别它作为快速排序所做的工作。

例如，C 版本的快速排序将第一次递归调用之前的所有数据分区。在 Haskell 版本中，结果的第一个元素将在 first 分区完成运行之前计算（甚至可能出现在您的屏幕上）——实际上是在 greater 上完成任何工作之前.

附：如果 Haskell 代码进行与快速排序相同数量的比较，它会更像快速排序；编写的代码进行了两倍的比较，因为lesser 和greater 被指定为独立计算，对列表进行两次线性扫描。当然，原则上编译器有可能足够聪明以消除额外的比较；或者代码可以改为使用Data.List.partition。

附言Haskell 算法的经典示例结果不符合您的预期，这是用于计算素数的 sieve of Eratosthenes。

Answer 7

我相信大多数人说漂亮的 Haskell 快速排序不是“真正的”快速排序的原因是它不是就地的 - 显然，在使用不可变数据类型时不可能。但也有人反对它不是“快速”：部分原因是昂贵的 ++，也因为存在空间泄漏 - 你在对较小元素进行递归调用时挂在输入列表上，并且在某些情况下 - 例如当列表减少时 - 这会导致二次空间使用。 （您可能会说，让它在线性空间中运行是使用不可变数据最接近“就地”的方法。）这两个问题都有很好的解决方案，使用累积参数、元组和融合；请参阅 Richard Bird 的 Introduction to Functional Programming Using Haskell 的 S7.6.1。

Answer 8

这不是在纯功能设置中就地改变元素的想法。该线程中使用可变数组的替代方法失去了纯洁精神。

快速排序的基本版本（也是最具表现力的版本）优化至少有两个步骤。

1. 通过累加器优化串联 (++)，这是一个线性运算：

   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. 优化三元快速排序（Bentley 和 Sedgewick 提到的 3 路分区），以处理重复元素：

   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. 结合 2 和 3，参考 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
   

或者，如果重复的元素不是多数：

    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

很遗憾，不能实现三中位数的相同效果，例如：

    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] 

因为它在以下 4 种情况下仍然表现不佳：

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, ... ]

所有这 4 种情况都可以通过命令式中位数方法很好地处理。

其实最适合纯函数设置的排序算法还是归并排序，而不是快速排序。

有关详细信息，请访问我正在进行的写作： https://sites.google.com/site/algoxy/dcsort

Answer 9

对于什么是真正的快速排序，什么不是真正的快速排序，没有明确的定义。

他们称它不是真正的快速排序，因为它不是就地排序：

C 中真正的快速排序就地排序

Answer 10

看起来 Haskell 版本会继续为其划分的每个子列表分配更多空间。因此，它可能会大规模耗尽内存。话虽如此，它更优雅。我想这就是你在选择函数式编程还是命令式编程时做出的权衡。

Answer 11

因为从列表中获取第一个元素会导致运行时非常糟糕。使用 3 的中位数：第一个、中间、最后一个。

Answer 12

请任何人在 Haskell 中编写快速排序，您将得到基本相同的程序——它显然是快速排序。以下是一些优点和缺点：

Pro：它通过稳定改进了“真正的”快速排序，即它保留了相等元素之间的序列顺序。

Pro：推广到三向拆分 () 很简单，这可以避免由于某些值出现 O(n) 次而导致的二次行为。

专业人士：它更容易阅读——即使必须包含过滤器的定义。

缺点：它使用更多内存。

缺点：通过进一步采样来概括枢轴选择的成本很高，这可以避免某些低熵排序上的二次行为。