Javascript 如何在Node.js上编写快速排序（Bentley McIlroy 3-way partitioning scheme）？

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

我有一个快速排序X模块：

"use strict";

const insertion = require('./insertion-sort');

module.exports = (function () {

  let _cutoff = 10;

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

  function _sort(array, lo, hi) {
    let size = hi - lo + 1;

    if (size <= _cutoff) {
      insertion.sort(array, lo, hi);
    } else {
      let eps = Math.floor(size/8);
      let mid = Math.floor(lo + size/2);
      let m1 = _median3(array, lo, lo + eps, lo + eps + eps);
      let m2 = _median3(array, mid - eps, mid, mid + eps);
      let m3 = _median3(array, hi - eps - eps, hi - eps, hi);

      let ninther = _median3(array, m1, m2, m3);
      _exch(array, ninther, lo);
    }

    let i = lo;
    let j = hi + 1;
    let p = lo;
    let q = hi + 1;
    let v = array[lo];

    while (true) {
      while (array[++i] < v) {
        if (i === hi) {
          break;
        }
      }
      while (v < array[--j]) {
        if (j === lo) {
          break;
        }
      }

      if (i === j && array[i] === v) {
        _exch(array, ++p, i);
      }

      if (i >= j) {
        break;
      }
      _exch(array, i, j);

      if (array[i] === v) {
        _exch(array, ++p, i);
      }
      if (array[j] === v) {
        _exch(array, --q, j);
      }
    }

    i = j + 1;

    for (let k = lo; k <= p; k++) {
      _exch(array, k, j--);
    }
    for (let k = hi; k >= q; k--) {
      _exch(array, k, i++);
    }

    _sort(array, lo, j);
    _sort(array, i, hi);
  }

  function _median3(array, i, j, k) {
    return (array[i] < array[j] ?
      (array[j] < array[k] ? j : array[i] < array[k] ? k : i) :
      (array[k] < array[j] ? j : array[k] < array[i] ? k : i));
  }

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

  return {
    sort: sort
  };

})();

“严格使用”；
常量插入=要求（'./插入排序'）；
module.exports=（函数（）{
设_截止=10；
函数排序（数组）{
_排序（数组，0，array.length-1）；
}
函数_排序（数组、lo、hi）{
让尺寸=高-低+1；
如果（尺寸=j）{
打破
}
_exch（数组，i，j）；
if（数组[i]==v）{
_exch（数组+p，i）；
}
if（数组[j]==v）{
_exch（数组，--q，j）；
}
}
i=j+1；
对于（设k=lo；k=q；k--）{
_exch（数组，k，i++）；
}
_排序（数组，lo，j）；
_排序（数组，i，hi）；
}
函数_median3（数组，i，j，k）{
返回（数组[i]<数组[j]？
（数组[j]<数组[k]？j:array[i]<数组[k]？k:i）：
（数组[k]

我使用mocha和chai测试此功能：

function isSorted(array) {
  for(let i = 1, size = array.length; i < size; i++) {
    if (array[i] < array[i-1]) {
      return false;
    }
  }
  return true;
}

函数已排序（数组）{
for（设i=1，size=array.length；i

快速排序不起作用。代码循环。我需要与书中相同的实现，但是在js上

---

您可以在此处看到原始实现：

在if

（size的
else
分支中，您有默认的快速排序实现

   function partioning(arr, left , right) // default qsort implementation
{
    var pivot = arr[Math.floor((left + right)/ 2)],
        i = left;
        j = right;
    var temp;
    while(i <= j)
    {
        while(arr[i] < pivot)
            i++;
        while(arr[j] > pivot)
            j--;
        if(i <= j)
        {
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
    }
    return i;
}
function quicksort(arr, left, right)
{
    var i = partioning(arr, left, right)

    if(left < i - 1)
        quicksort(arr, left, i - 1);
    if(right > i)
        quicksort(arr, i, right);
    return arr;
}

函数分区（arr、左、右）//默认qsort实现
{
var pivot=arr[数学楼层（（左+右）/2）]，
i=左；
j=右；
无功温度；
而（我）
j--；
如果（i）
快速排序（arr，i，右）；
返回arr；
}

但是，您可以改进此算法

// 3 way quicksort

    function sort(a, lo, hi) {
        if(hi <= lo) return a;
        var lt = lo, gt = hi;
        var v = a[lo];
        var i = lo
        while(i <= gt)
        {
            if(a[i] < v) {
                swap(a, lt, i)
                i++;
                lt++
            } else if(a[i] > v) {
                  swap(a, i, gt)
                  gt--;
            } else {
                i++;
            }

        }
        sort(a, lo, lt - 1)
        sort(a, gt + 1, hi)
    }

//3路快速排序
函数排序（a、lo、hi）{
如果（嗨