Javascript 如何在Node.js上编写快速排序

我正在继续尝试在Node.js上写一个alrorithms，就像韦恩的《算法》一书第四版一样。这里有所有用Java编写的示例

我有一个快速分拣模块：

"use strict";

const _ = require('lodash');

module.exports = (function () {

  function _partition(array, lo, hi) {
    let i = lo;
    let j = hi + 1;
    let v = array[lo];

    while (true) {
      while (_less(array[++i], v)) {
        if (i === hi) {
          break;
        }
      }
      while (_less(v, array[--j])) {
        if (j === lo) {
          break;
        }
      }
      if (i >= j) {
        break;
      }
      _exch(array, i, j);
    }
    _exch(array, lo, j);
    return j;
  }

  function sort(array) {
    _sort(array, 0, array.length - 1);
  }

  function _sort(array, lo, hi) {
    if (hi <= lo) {
      return null;
    }

    let j = _partition(array, lo, hi);

    _sort(array, lo, j - 1);
    _sort(array, j + 1, hi);
  }

  function _less(array, i, min) {
    return array[i] < array[min];
  }

  function _exch(array, i, min) {
    let temp = array[i];
    array[i] = array[min];
    array[min] = temp;
  }

  return {
    sort: sort
  };

})();

“严格使用”；
const=require（'lodash'）；
module.exports=（函数（）{
函数分区（数组、lo、hi）{
设i=lo；
设j=hi+1；
设v=数组[lo]；
while（true）{
而（_-less（数组[++i]，v））{
如果（i==hi）{
打破
}
}
而（_-less（v，数组[--j]））{
如果（j==lo）{
打破
}
}
如果（i>=j）{
打破
}
_exch（数组，i，j）；
}
_exch（数组，lo，j）；
返回j；
}
函数排序（数组）{
_排序（数组，0，array.length-1）；
}
函数_排序（数组、lo、hi）{
如果（hi，那么实现是丑陋的

很抱歉，我无法帮助您回答课程问题，但这里是quicksort功能递归版本的妙处。永远不要在javascript中使用上述内容

在ES6中

功能上递归的快速排序

const quicksort = ([head, ...tail]) => head === undefined ? [] : 
  [...quicksort([...tail.filter(a => a <= head)]), head, ...quicksort([...tail.filter(a => a > head)])];

这一实施是丑陋的

很抱歉，我无法帮助您回答课程问题，但这里是quicksort功能递归版本的妙处。永远不要在javascript中使用上述内容

在ES6中

功能上递归的快速排序

const quicksort = ([head, ...tail]) => head === undefined ? [] : 
  [...quicksort([...tail.filter(a => a <= head)]), head, ...quicksort([...tail.filter(a => a > head)])];

函数
\u less
使用索引作为参数：

  function _less(array, i, min) {
    return array[i] < array[min];

（省略第一个参数
array
-在JS中合法吗？
您的函数
\u less
使用索引作为参数：

  function _less(array, i, min) {
    return array[i] < array[min];

（省略第一个参数
array
-在JS中合法吗？

我能想到的最简单（可读性最高）的快速排序函数


快速排序（可读性是重点）

让快速排序=（项=[]，左=[]，右=[]）=>{
如果（项目长度）（项目<枢轴？左：右）。推（项目）
项目。forEach（推侧）
return[…快速排序（左），pivot，…快速排序（右）]
}

注：编写上述相同逻辑的其他两种方法如下


for循环而不是foreach

let quickSort=（arr=[]，left=[]，right=[]）=>{
if（arr.length{
if（项目长度（项目<枢轴？左：右）。推（项目））
return[…快速排序（左），pivot，…快速排序（右）]；
}


在js/node.js中创建的其他排序的简短列表，以及对一些有用链接的引用


let sort={
快速：（项目=[]，左=[]，右=[]）=>{
如果（项目长度）（项目<枢轴？左：右）。推（项目）
项目。forEach（推侧）
return[…sort.quick（左），pivot，…sort.quick（右）]
},
气泡：（项目=[]）=>{
for（设passover=0；passover项目[索引+1]）
{
let temporary=项目[索引]
项目[索引]=项目[索引+1]
项目[索引+1]=临时
}
}
}
退货项目；
},
选择：（项目=[]）=>{
for（让过程=0；过程{
for（设i=1；i=0&&items[index]>临时）
{
项目[索引+1]=项目[索引]
索引--
}
项目[索引+1]=临时
}
退货项目
},
}
console.log（'quick:'，sort.quick（[0,43,3,2,3,4]））
log（“select:”，sort.select（[0,43,3,2,3,4]））
console.log（“insert:”，sort.insert（[0,43,3,2,3,4]））
console.log（“bubble:，sort.bubble（[0,43,3,2,3,4]））

sort.quick O（n log n）平均时间复杂度
sort.O（n^2）平均时间复杂度
sort.insert O（n^2）平均时间复杂度
sort.select O（n^2）平均时间复杂度




我能想到的最简单（可读性最高）的快速排序函数


快速排序（可读性是重点）

让快速排序=（项=[]，左=[]，右=[]）=>{
如果（项目长度）（项目<枢轴？左：右）。推（项目）
项目。forEach（推侧）
return[…快速排序（左），pivot，…快速排序（右）]
}

注：编写上述相同逻辑的其他两种方法如下


for循环而不是foreach

let quickSort=（arr=[]，left=[]，right=[]）=>{
if（arr.length{
if（项目长度（项目<枢轴？左：右）。推（项目））
return[…快速排序（左），pivot，…快速排序（右）]；
}


在js/node.js中创建的其他排序的简短列表，以及对一些有用链接的引用


let sort={
快速：（项目=[]，左=[]，右=[]）=>{
如果（项目长度）（项目<枢轴？左：右）。推（项目）
项目。forEach（推侧）
return[…sort.quick（左），pivot，…sort.quick（右）]
},
气泡：（项目=[]）=>{
for（设passover=0；passover项目[索引+1]）
{
let temporary=项目[索引]
项目[索引]=项目[索引+1]
项目[索引+1]=临时
}
}
}
退货项目；
},
选择：（项目=[]）=>{
for（让过程=0；过程 let v = array[lo];
 while (_less(array[++i], v)