Sorting 在clojure中按索引值将2d向量排序为惰性序列

我正在阅读Clojure的喜悦，遇到了一个快速排序的实现，它使用惰性序列来实现优于O（n log n）的性能，而只从惰性序列中提取前几个cons单元格。我试图让它在二维整数数组中工作，但我似乎无法完全实现： 到目前为止，这就是我所拥有的：

(defn sort-parts2
  "Lazy, tail-recursive, incremental quicksort. Works against
   and creates partitions based on the pivot, defined as 'work'."
  [work]
  (lazy-seq
    (loop [[part & parts] work]
      (if-let [[pivot & xs] (seq part)]
        (let [smaller? #(< % pivot)]
          (recur (list*
                 (filter smaller? xs)
                 pivot
                 (remove smaller? xs)
                 parts)))
      (when-let [[x & parts] parts] 
      (cons x (sort-parts2 parts)))))))



   sort.joy=> a
    [[5 9 0 6 5 1 4 4 8 7]
     [2 6 8 2 6 7 0 1 8 1]
     [8 8 0 5 9 9 7 7 1 6]
     [9 8 5 3 0 2 0 6 9 3]
     [8 8 5 8 9 8 2 3 8 5]
     [7 9 2 8 5 6 6 8 3 4]
     [4 8 2 4 6 6 7 4 4 1]
     [8 5 1 7 3 0 2 4 2 3]
     [9 1 2 9 0 1 0 2 2 9]
     [4 0 2 6 8 5 6 1 7 7]]

事实上，这就是我现在得到的：

sort.joy=> (sort-parts a)
(0
 1
 4
 4
 5
 5
 6
 7
 8
 9
 [2 6 8 2 6 7 0 1 8 1]
 0
 1
 5
 6
 7
 7
 8
 8
 9
 9
 [9 8 5 3 0 2 0 6 9 3]
 2
 3
 5
 5
 8
 8
 8
 8
 8
 9
 [7 9 2 8 5 6 6 8 3 4]
 1
 2
 4
 4
 4
 4
 6
 6
 7
 8
 [8 5 1 7 3 0 2 4 2 3]
 0
 0
 1
 1
 2
 2
 2
 9
 9
 9
 [4 0 2 6 8 5 6 1 7 7])

有人能帮我找出一种方法来阻止循环完全分解2d向量，从而返回一个头部为行向量的惰性向量吗？我已经计算出了行的比较器，谢谢

edit这个问题的更一般的表述：我想把一个二维向量，如下面的

a

分成一个惰性序列，其中头部是由索引排序的下一个子向量。要非惰性地完成此操作，我使用：

(defn sortVector 
  "sorts a 2d vector by the given index"
  [index coll]
  (sort-by #(nth % index) coll))

---

如果从原始的JoC代码开始，并将

较小的

函数替换为一个比较

pivot

上某些关键函数的值和另一项的函数，而不是直接比较这些项，则可以从JoC代码派生出

按

对零件进行排序的函数：

(let [pivot-key (keyfn pivot)
      smaller? #(.compare ^java.util.Comparator comp
                          (keyfn %1)
                          pivot-key)]
  ...)

名称

keyfn

和

comp

来自

clojure.core/sort by

——有关预期含义，请参见其docstring/implementation

---

请注意，

sort parts

并不打算对要排序的实际序列进行调用——您必须首先将其包装为某种seqable（可能是一个向量）；有关示例，请参见JoC中

qsort

的定义。您可能需要一个

qsort by

与上面所示的函数配合使用。

如果从原始函数开始，并将

较小的

函数替换为比较

透视

上某个关键函数的值和另一项的函数，您可以从JoC代码派生出一个

按

排序的函数，而不是直接的项目：

(let [pivot-key (keyfn pivot)
      smaller? #(.compare ^java.util.Comparator comp
                          (keyfn %1)
                          pivot-key)]
  ...)

名称

keyfn

和

comp

来自

clojure.core/sort by

——有关预期含义，请参见其docstring/implementation

请注意，

sort parts

并不打算对要排序的实际序列进行调用——您必须首先将其包装为某种seqable（可能是一个向量）；有关示例，请参见JoC中

qsort

的定义。您可能需要一个

qsort by

与上面所示的函数配合使用