通过索引值将2d向量排序为clojure中的惰性序列

Question

我正在阅读Joy Of Clojure并遇到了一种快速排序的实现方法，该方法使用延迟序列比只使用O（n log n）时的性能更好来自懒惰序列的第一批反义细胞。我试图让它为整数的二维数组工作，但我不能完全似乎得到它： 到目前为止，这是我：

(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-parts2 a 0) //指标是：

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

原样，这就是我现在越来越：

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]) 

可能有人请帮助我OU如何阻止循环完全解构2D矢量，从而返回一个懒惰矢量，头部是行矢量？我有排列的比较数据，谢谢！问题的

编辑更一般的配方：我想排序2d矢量，视为a波纹管成懒惰序列，其中所述头部是由索引排序下一子矢量。如果用原来的开始，并与其中一个的值进行比较的一些关键功能的替代smaller?功能

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

Answer 1

可以派生从JOC代码sort-parts-by功能：要做到这一点不懒惰，我使用在pivot和另一个项目，而不是直接的项目：

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

名称keyfn和comp来自clojure.core/sort-by - 看到它的文档字符串/实施的本意。

请注意，sort-parts不打算在实际的排序序列上被调用 - 你必须首先将它包装在某种seqable中（可能是一个向量）。以JoC中的qsort的定义为例。你可能会想要一个qsort-by与上面描绘的功能一起。