C'est un peu horrible à cause des macros, mais avec ce code, je pense que vous pouvez faire correspondre la vitesse Java (je reçois environ 11ms pour le benchmark):

(set! *unchecked-math* true)

(defmacro swap [a i j]
  `(let [a# ~a
         i# ~i
         j# ~j
         t# (aget a# i#)]
     (aset a# i# (aget a# j#))
     (aset a# j# t#)))

(defmacro apartition [a pivot i j]
  `(let [pivot# ~pivot]
     (loop [i# ~i
            j# ~j]
       (if (<= i# j#)
         (let [v# (aget ~a i#)]
           (if (< v# pivot#)
             (recur (inc i#) j#)
             (do 
               (when (< i# j#) 
                 (aset ~a i# (aget ~a j#))
                 (aset ~a j# v#))
               (recur i# (dec j#)))))
         i#))))

(defn qsort 
  ([^longs a]
    (qsort a 0 (alength a)))
  ([^longs a ^long lo ^long hi]    
    (let [lo (int lo)
          hi (int hi)]
      (when
        (< (inc lo) hi)
        (let [pivot (aget a lo)
              split (dec (apartition a pivot (inc lo) (dec hi)))]
          (when (> split lo) (swap a lo split))
          (qsort a lo split)
          (qsort a (inc split) hi)))
      a)))

Les principales astuces sont:

• Faites tout avec l'arithmétique primitive
• Utilisez ints pour les index de tableau (cela évite certains casts inutiles, pas un gros problème mais chaque petit aide....)
• Utilisez des macros plutôt que des fonctions pour briser le code (évite les frais généraux d'appel de fonction et la boxe de paramètre)
• Utilisation boucle / récur pour la vitesse maximale dans la boucle interne (c'est-à-dire le partitionnement du sous-tableau)
• évitez de construire de nouveaux objets sur le tas (évitez donc les vecteurs, les séquences,les cartes, etc.)

La Joie de Clojure, Chapitre 6.4 décrit un algorithme de quicksort paresseux.La beauté du tri paresseux est qu'il ne fera que le travail nécessaire pour trouver les premières valeurs X. Donc, si x

(ns joy.q)

(defn sort-parts
  "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-parts parts)))))))

(defn qsort [xs]
    (sort-parts (list xs))) 

En examinant les principaux points de la réponse de mikera, vous pouvez voir qu'ils sont principalement axés sur l'élimination de la surcharge introduite en utilisant idiomatique (par opposition à tweaked) Clojure, qui n'existerait probablement pas dans une implémentation Java idiomatique:

• arithmétique primitive - légèrement plus facile et plus idiomatique en Java, vous êtes plus susceptible d'utiliser int s que Integer s
• ints pour les index de Tableau - le même
• utiliser des macros plutôt que fonctions pour briser le code (évite les frais généraux d'appel fonctionnels et la boxe) - corrige un problème introduit en utilisant le langage. Clojure encourage le style fonctionnel, d'où un frais généraux d'appel de fonction (et la boxe).
• Utilisez loop / recur pour la vitesse maximale dans la boucle interne - en Java, vous utiliseriez idiomatiquement une boucle ordinaire (ce que loop/recur compile de toute façon, pour autant que je sache)

Cela étant dit, il existe en fait une autre solution triviale. Écrire (ou de trouver) une implémentation Java efficace de Quick Sort, dites quelque chose avec une signature comme ceci:

Sort.quickSort(long[] elems)

Et puis appelez-le de Clojure:

(Sort/quickSort elems)

Liste de contrôle:

• Aussi efficaces Que dans Java - oui

• Idiomatique dans Clojure - sans doute oui , je dirais que Java-interop est l'une des fonctionnalités de base de Clojure.

• Réutilisable - oui, il ya une bonne chance que vous pouvez facilement trouver un très efficace Implémentation Java déjà écrite.

_{Je n'essaie pas de troll, je comprends ce que vous essayez de découvrir avec ces expériences, je n'ajoute que cette réponse par souci d'exhaustivité. Ne négligeons pas le plus évident! :)}