JavaScript快速排序

我已经在网上浏览了一段时间，我想知道是否有一个“稳定的”快速排序的实际实现是普遍使用的？我可以自己写，但为什么要重新发明轮子

将对象放入数组中

打电话。非常快

var array = [3,7,2,8,2,782,7,29,1,3,0,34];
array.sort();
console.log(array); // prints [0, 1, 2, 2, 29, 3, 3, 34, 7, 7, 782, 8]

为什么按字典顺序打印？默认情况下，

array.sort（）

就是这样工作的，例如，如果您不提供比较器函数，。我们来解决这个问题

    var array = [3,7,2,8,2,782,7,29,1,3,0,34];
    array.sort(function (a, b)
    {
        return a-b;
    });
    console.log(array); // prints [0, 1, 2, 2, 3, 3, 7, 7, 8, 29, 34, 782]

您可以使用装饰排序取消装饰模式轻松“稳定”不稳定的排序

function stableSort(v, f)
{
    if (f === undefined) {
        f = function(a, b) {
            a = ""+a; b = ""+b;
            return a < b ? -1 : (a > b ? 1 : 0);
        }
    }
    var dv = [];
    for (var i=0; i<v.length; i++) {
        dv[i] = [v[i], i];
    }
    dv.sort(function(a, b){
              return f(a[0], b[0]) || (a[1] - b[1]);
            });
    for (var i=0; i<v.length; i++) {
        v[i] = dv[i][0];
    }
}

功能稳定端口（v，f）
{
如果（f==未定义）{
f=函数（a，b）{
a=“”+a；b=“”+b；
返回ab-1:0）；
}
}
var-dv=[]；
对于（var i=0；i，在这个博客中指出
Array.sort在快速排序或内部合并排序中实现

快速排序通常被认为是高效和快速的，也是如此
V8将其用作数组上的Array.prototype.sort（）的实现
超过23项。对于少于23项，V8使用插入
排序[2]。合并排序是quicksort的竞争对手，因为它也是
高效、快速，但具有稳定的附加好处。这是
为什么Mozilla和Safari使用它来实现
Array.prototype.sort（）

当使用Array.sort时，在Chrome中应该返回-1 0 1，而不是true或false

arr.sort(function(a,b){
  return a<b;
});
// maybe--> [21, 0, 3, 11, 4, 5, 6, 7, 8, 9, 10, 1, 2, 12, 13, 14, 15, 16, 17, 18, 19, 20, 22]
arr.sort(function(a,b){
  return a > b ? -1 : a < b ? 1 : 0;
});
// --> [22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

arr.sort（函数（a，b）{
返回[21,0,3,11,4,5,6,7,8,9,10,1,2,12,13,14,15,16,17,18,19,20,22]
arr.sort（函数（a，b）{
返回a>b-1:a [22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

var数组=[8,2,5,7,4,3,12,6,19,11,10,13,9]；
快速排序（数组，0，array.length-1）；
document.write（数组）；
函数快速排序（arr、左、右）
{
var i=左；
var j=右；
var-tmp；
pivotidx=（左+右）/2；
var pivot=parseInt（arr[pivotidx.toFixed（））；
/*分割*/
而（我）
j--；
如果（i此算法的工作速度几乎与默认实现一样快
在chrome中使用Array.prototype.sort

function quickSort(t){
    _quickSort(t,0,t.length-1,0,t.length-1);
}

function _quickSort(t, s, e, sp, ep){   
    if( s>=e )  return;
    while( sp<ep && t[sp]<t[e] ) sp++;  
    if( sp==e )
        _quickSort(t,s,e-1,s,e-1);  
    else{
        while(t[ep]>=t[e] && sp<ep ) ep--;      
        if( sp==ep ){
            var temp = t[sp];
            t[sp] = t[e];
            t[e] = temp;
            if( s!=sp ){
                _quickSort(t,s,sp-1,s,sp-1);
            }
            _quickSort(t,sp+1,e,sp+1,e);            
        }else{
            var temp = t[sp];
            t[sp] = t[ep];
            t[ep] = temp;
            _quickSort(t,s,e,sp+1,ep);
        }
    }
}

函数快速排序（t）{
_快速排序（t，0，t.length-1,0，t.length-1）；
}
函数_快速排序（t，s，e，sp，ep）{
如果（s>=e）返回；
而（sp快速排序（递归）


函数快速排序（数组）{
if（array.length）是等效函数
为了庆祝功能性Javascript，它似乎是

目前，特别是考虑到ES6+奇妙的语法糖添加。箭头函数和解构我提出了一个非常干净、简短的功能等价物快速排序函数。我没有测试它的性能，也没有将它与内置的快速排序函数进行比较，但它可能会帮助那些努力理解实际的u快速排序的se。鉴于其声明性质，很容易看到发生了什么，而不是它是如何工作的

这是一个没有注释的JSBin版本

函数quickSortF（arr）{
//基本情况
如果（！arr.length）返回[]
//这是一个ES6添加，它使用解构来拉出
//第一个值和其他值，类似于其他函数式语言
//比如Haskell，Scala，你可以这样做
//正常以下
常数[头，…尾]=arr，
//在这里，我们使用箭头函数，并充分利用
//简洁语法的优势，详细版本的
//函数（e）=>{returnee<头部），
右=尾部。过滤器（e=>e>=头部）
//这是“分而治之”的征服部分
//递归地遍历每个左数组和右数组
//直到我们到达返回空值的if条件
//数组。这些结果都使用concat连接，
//我们得到了我们的排序数组。
返回quickSortF（左）。concat（头部，quickSortF（右））
}
常数q7=快速排序（[11,8,14,3,6,2,7]）
//[2, 3, 6, 7, 8, 11, 14]
常数q8=快速排序（[11,8,14,3,6,2,1,7]）
//[1, 2, 3, 6, 7, 8, 11, 14]
常量q9=快速排序（[16,11,9,7,6,5,3,2]）
//[2, 3, 5, 6, 7, 9, 11, 16]
控制台日志（q7、q8、q9）

如果已经不清楚发生了什么，注释应该提供足够的信息。实际代码非常短，没有注释，您可能已经注意到我不喜欢分号。
又是一个快速排序演示，它以数组的中间部分为轴心，没有具体原因

const QuickSort = function (A, start, end) {
    // 
    if (start >= end) {
        return;
    }
    // return index of the pivot
    var pIndex = Partition(A, start, end);
    // partition left side
    QuickSort(A, start, pIndex - 1);
    // partition right side
    QuickSort(A, pIndex + 1, end);
}

const Partition = function (A, start, end) {
    if (A.length > 1 == false) {
        return 0;
    }
    let pivotIndex = Math.ceil((start + end) / 2);
    let pivotValue = A[pivotIndex];
    for (var i = 0; i < A.length; i++) {
        var leftValue = A[i];
        // 
        if (i < pivotIndex) {
            if (leftValue > pivotValue) {
                A[pivotIndex] = leftValue;
                A[i] = pivotValue;
                pivotIndex = i;
            }
        }
        else if (i > pivotIndex) {
            if (leftValue < pivotValue) {
                A[pivotIndex] = leftValue;
                A[i] = pivotValue;
                pivotIndex = i;
            }
        }
    }
    return pivotIndex;

}

const QuickSortTest = function () {
    const arrTest = [3, 5, 6, 22, 7, 1, 8, 9];
    QuickSort(arrTest, 0, arrTest.length - 1);
    console.log("arrTest", arrTest);
}
// 
QuickSortTest();

const QuickSort=函数（A、开始、结束）{
// 
如果（开始>=结束）{
返回；
}
//枢轴的返回索引
var pIndex=分区（A，开始，结束）；
//隔板左侧
快速排序（A，开始，pIndex-1）；
//右侧隔板
快速排序（A，pIndex+1，结束）；
}
常量分区=函数（A、开始、结束）{
如果（A.length>1==false）{
返回0；
}
让pivotIndex=Math.ceil（（开始+结束）/2）；
设pivotValue=A[pivotIndex]；
对于（变量i=0；ipivotValue）{
[pivotIndex]=左值；
A[i]=数据透视值；
数据透视指数=i；
}
}
else if（i>数据透视索引）{
如果（leftValueconst QuickSort = function (A, start, end) {
    // 
    if (start >= end) {
        return;
    }
    // return index of the pivot
    var pIndex = Partition(A, start, end);
    // partition left side
    QuickSort(A, start, pIndex - 1);
    // partition right side
    QuickSort(A, pIndex + 1, end);
}

const Partition = function (A, start, end) {
    if (A.length > 1 == false) {
        return 0;
    }
    let pivotIndex = Math.ceil((start + end) / 2);
    let pivotValue = A[pivotIndex];
    for (var i = 0; i < A.length; i++) {
        var leftValue = A[i];
        // 
        if (i < pivotIndex) {
            if (leftValue > pivotValue) {
                A[pivotIndex] = leftValue;
                A[i] = pivotValue;
                pivotIndex = i;
            }
        }
        else if (i > pivotIndex) {
            if (leftValue < pivotValue) {
                A[pivotIndex] = leftValue;
                A[i] = pivotValue;
                pivotIndex = i;
            }
        }
    }
    return pivotIndex;

}

const QuickSortTest = function () {
    const arrTest = [3, 5, 6, 22, 7, 1, 8, 9];
    QuickSort(arrTest, 0, arrTest.length - 1);
    console.log("arrTest", arrTest);
}
// 
QuickSortTest();

smaller = (a, list) => list.filter(x => x <= a)
larger = (a, list) => list.filter(x => x > a)
qsort = ([x, ...list]) => (!isNaN(x))
    ? [...qsort(smaller(x, list)), x, ...qsort(larger(x, list))]
    : []

function typeCheck(a, b){
  if(typeof a === typeof b){
    return true;
  }else{
    return false;
  }
}

function qSort(arr){
  if(arr.length === 0){
    return [];
  }

  var leftArr = [];
  var rightArr = [];
  var pivot = arr[0];

  for(var i = 1; i < arr.length; i++){
    if(typeCheck(arr[i], parseInt(0))){
      if(arr[i] < pivot){
        leftArr.push(arr[i]);
      }else { rightArr.push(arr[i]) } 
    }else{
      throw new Error("All must be integers");
    }
  }

  return qSort(leftArr).concat(pivot, qSort(rightArr));

}

var test = [];

for(var i = 0; i < 10; i++){
  test[i] = Math.floor(Math.random() * 100 + 2);
}

console.log(test);
console.log(qSort(test));

function quickSort(arr) {
  if (arr.length < 2) {
    return arr;
  }
  const pivot = arr[Math.floor(Math.random() * arr.length)];

  let left = [];
  let right = [];
  let equal = [];

  for (let val of arr) {
    if (val < pivot) {
      left.push(val);
    } else if (val > pivot) {
      right.push(val);
    } else {
      equal.push(val);
    }
  }
  return [
    ...quickSort(left),
    ...equal,
    ...quickSort(right)
  ];
}

function swap(arr,a,b){
    let temp = arr[a]
    arr[a] = arr[b]
    arr[b] = temp
    return 1
}

function qS(arr, first, last){
    if(first > last) return

    let p = first
    for(let i = p; i < last; i++)
        if(arr[i] < arr[last]) 
            p += swap(arr, i, p)

    swap(arr, p, last)

    qS(arr, first, p - 1)
    qS(arr, p + 1, last)
}

const quicksort = (arr, comp, iArr = arr) => {
  if (arr.length < 2) {
    return arr;
  }
  const isInitial = arr.length === iArr.length;
  const arrIndexes = isInitial ? Object.keys(arr) : arr;
  const compF = typeof comp === 'function'
  ? comp : (left, right) => left < right ? -1 : right < left ? 1 : 0;
  const [pivotIndex, ...indexesSansPivot] = arrIndexes;
  const indexSortReducer = isLeftOfPivot => [
    (acc, index) => isLeftOfPivot === (compF(iArr[index], iArr[pivotIndex]) === -1)
    ? acc.concat(index) : acc,
    []
  ];
  const ret = quicksort(indexesSansPivot.reduce(...indexSortReducer(true)), compF, iArr)
  .concat(pivotIndex)
  .concat(quicksort(indexesSansPivot.reduce(...indexSortReducer(false)), compF, iArr));
  return isInitial ? ret.reduce((acc, index) => acc.concat([arr[index]]), []) : ret;
};

quickSort = (array, left, right) => {
    if (left >= right) {
        return;
    }
    const pivot = array[Math.trunc((left + right) / 2)];
    const index = partition(array, left, right, pivot);
    quickSort(array, left, index - 1);
    quickSort(array, index, right);
}

partition = (array, left, right, pivot) => {
    while (left <= right) {
        while (array[left] < pivot) {
            left++;
        }
        while (array[right] > pivot) {
            right--;
        }
        if (left <= right) {
            swap(array, left, right);
            left++;
            right--;
        }
    }
    return left;
}

swap = (array, left, right) => {
    let temp = array[left];
    array[left] = array[right];
    array[right] = temp;
}
let array = [1, 5, 2, 3, 5, 766, 64, 7678, 21, 567];
quickSort(array, 0, array.length - 1);
console.log('final Array: ', array);

let QuickSort = (arr, low, high) => {
    if (low < high) {
        p = Partition(arr, low, high);
        QuickSort(arr, low, p - 1);
        QuickSort(arr, p + 1, high);
    }
    return arr.A;
}

let Partition = (arr, low, high) => {
    let pivot = arr.A[high];
    let i = low;
    for (let j = low; j <= high; j++) {
        if (arr.A[j] < pivot) {
            [arr.A[i], arr.A[j]] = [arr.A[j], arr.A[i]];
            i++;
        }
    }
    [arr.A[i], arr.A[high]] = [arr.A[high], arr.A[i]];
    return i;
}

let arr = { A/* POINTER */: [33, 22, 88, 23, 45, 0, 44, 11] };
let res = QuickSort(arr, 0, arr.A.length - 1);
console.log(res);

let Partition = (arr, low, high) => {
    let pivot = arr.A[high];
    let index = arr.I[high];
    let i = low;
    for (let j = low; j <= high; j++) {
        if (arr.A[j] + (arr.I[j] * influencer) < pivot + (index * influencer)) {
            [arr.A[i], arr.A[j]] = [arr.A[j], arr.A[i]];
            [arr.I[i], arr.I[j]] = [arr.I[j], arr.I[i]];
            i++;
        }
    }
    [arr.A[i], arr.A[high]] = [arr.A[high], arr.A[i]];
    [arr.I[i], arr.I[high]] = [arr.I[high], arr.I[i]];
    return i;
}

let influencer = 0.0000001;

let arr = {
    I/* INDEXES */: [10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
    A/* POINTER */: [33, 22, 88, 33, 23, 45, 33, 89, 44, 11]
};
let res = QuickSort(arr, 0, arr.A.length - 1);
console.log(res);

I: [19, 11, 14, 10, 13, 16, 18, 15, 12, 17],
A: [11, 22, 23, 33, 33, 33, 44, 45, 88, 89]