Javascript 在原型数组上实现快速排序递归函数 Array.prototype.quickSort=函数（）{ 让自我=这个； 设len=自身长度； 让我们来看看你的位置； 让结果=[] if（len左。快速排序（）； 错误-->右侧。快速排序（）； 控制台日志（左）； console.log（右）； //right_pivot_pos=right.partition（）； 归还这个； } Array.prototype.partition=函数（）{ 让arr=这个； 让枢轴位置=数学地板（（arr.length-1）/2）； 设last_small=arr[0] 让我； //log（`this[0]${this[0]}之前和this[pivot_pos]之前） ${this[pivot_pos]}`）； [arr[pivot_pos]，arr[0]=[arr[0]，arr[pivot_pos]]； //log（`this[0]${this[0]}和this[pivot_pos] ${this[pivot_pos]}`）； 对于（i=1；i

i），请在下面列出代码的固定版本。最重要的固定版本包括：

• 在

  partition

  中，变量

  last\u small

  包含元素的值，但它稍后在循环中用作索引
• 在

  分区中

  总是将元素与索引0进行比较，而不是移动枢轴元素

• quicksort

  函数保持对2元素数组的分区和排序。因此出现内存溢出异常
• 完成后不会重建原始阵列。请注意，splice会修改原始阵列

Array.prototype.quickSort=函数（）{
var self=这个；
如果（自身长度<2）{
回归自我
}
var pivot_pos=self.partition（）；
如果（自身长度>2）{
var left=自拼接（0，枢轴位置）；
右侧变量=自拼接（0）；
self.splice.apply（self[0,0].concat（right.quickSort（））；
self.splice.apply（self[0,0].concat（left.quickSort（））；
}
归还这个；
};
Array.prototype.swap=函数（i，j）{
var tmp=该[i]；
这个[i]=这个[j]；
这个[j]=tmp；
};
Array.prototype.partition=函数（）{
var self=这个；
var pivot_pos=数学楼层（（自身长度-1）/2）；
var last_small_i=0；
自交换（最后一个小的轴位置）；
对于（变量i=1；iconsole.log（sandbox.quickSort（））；

我在下面列出了代码的固定版本。最重要的固定版本包括：

• 在

  partition

  中，变量

  last\u small

  包含元素的值，但它稍后在循环中用作索引
• 在

  分区中

  总是将元素与索引0进行比较，而不是移动枢轴元素

• quicksort

  函数保持对2元素数组的分区和排序。因此出现内存溢出异常
• 完成后不会重建原始阵列。请注意，splice会修改原始阵列

Array.prototype.quickSort=函数（）{
var self=这个；
如果（自身长度<2）{
回归自我
}
var pivot_pos=self.partition（）；
如果（自身长度>2）{
var left=自拼接（0，枢轴位置）；
右侧变量=自拼接（0）；
self.splice.apply（self[0,0].concat（right.quickSort（））；
self.splice.apply（self[0,0].concat（left.quickSort（））；
}
归还这个；
};
Array.prototype.swap=函数（i，j）{
var tmp=该[i]；
这个[i]=这个[j]；
这个[j]=tmp；
};
Array.prototype.partition=函数（）{
var self=这个；
var pivot_pos=数学楼层（（自身长度-1）/2）；
var last_small_i=0；
自交换（最后一个小的轴位置）；
对于（变量i=1；i

Array.prototype.swap=function（i，j）{ var tmp=该[i]； 这个[i]=这个[j]； 这个[j]=tmp； }; Array.prototype.\u quicksort=函数（A，i，j）{ 如果（i>=j）{ 返回； } 如果（i+1==j）{ 如果（A[i]>A[j]）{ A.互换（i，j）； } 返回； } var p=数学层（（i+j）/2）； A.互换（i，p）； var l=i； var r=j； 而（l

Array.prototype.swap=函数（i，j）{
var tmp=该[i]；
这个[i]=这个[j]；
这个[j]=tmp；
};
Array.prototype.\u quicksort=函数（A，i，j）{
如果（i>=j）{
返回；
}
如果（i+1==j）{
如果（A[i]>A[j]）{
A.互换（i，j）；
}
返回；
}
var p=数学层（（i+j）/2）；
A.互换（i，p）；
var l=i；
var r=j；
while（我能问一下这行代码吗？我不明白[0,0]指的是.self.splice.apply（self[0,0].concat（right.quickSort（））；
[0,0].concat（right.quickSort（））
0，0

在已排序的右侧分区的开始处预先添加

0，0

。

0，0

是

splice

的前两个参数，意味着在位置0添加项并删除0项。splice不希望数组作为其项参数；通过使用

apply

可以直接将项数组传递给

splice>而不是必须迭代它们并逐个添加。嗨，我刚刚做了一个测试，如果我使用[1,10,6,5,4,3,7,9]的话，它会在数组至少2秒内出现时出现错误。我真的不明白你的意思，但我用那个输入测试了它，它仍然有效。当我输入1,10,6,5,4,3,7,9时，结果是
Array.prototype.quickSort = function () {
let self = this;
let len = self.length;
let pivot_pos;
let result = []
if (len < 2) {
  return self
}
pivot_pos = self.partition();
let left = self.splice(0, pivot_pos),
right = self.splice(0);


error --> left.quickSort();
error --> right.quickSort();

console.log(left);
console.log(right);
//right_pivot_pos = right.partition();

return this;
}

Array.prototype.partition = function () {
    let arr = this;
    let pivot_pos = Math.floor((arr.length-1)/2);
let last_small = arr[0]
let i;
//console.log(`before this[0] ${this[0]} and before this[pivot_pos] 
${this[pivot_pos]}`);
[arr[pivot_pos], arr[0]] = [arr[0], arr[pivot_pos]];
//console.log(`this[0] ${this[0]} and this[pivot_pos] 
${this[pivot_pos]}`);

 for (i=1;i<arr.length; i++) {
   if(arr[i]<arr[0]) {
     //[this[i], this[num]] = [this[num], this[i]];
     let tmp = arr[last_small];
     arr[last_small] = arr[i];
     arr[i] = tmp;
     last_small++;
     }
   }
 [arr[0], arr[last_small-1]] = [arr[last_small-1], arr[0]];
 return last_small;
}

let sandbox = [1,2,6,5,4,3,7,9];
console.log(sandbox.quickSort());

Array.prototype.swap = function (i, j) {
    var tmp = this[i];
    this[i] = this[j];
    this[j] = tmp;
};

Array.prototype._quicksort = function(A, i, j) {
    if (i >= j) {
        return;
    }
    if (i+1 == j) {
        if (A[i] > A[j]) {
            A.swap(i,j);
        }
        return;
    }

    var p = Math.floor((i+j)/2);
    A.swap(i, p);

    var l = i;
    var r = j;
    while (l <= r) {
        if (A[l] <= A[i]) {
            l++;
        } else if (A[r] > A[i]) {
            r--;
        } else {
            A.swap(l, r);
            l++;
            r--;
        }
    }

    p = l-1;
    A.swap(i, p);

    Array.prototype._quicksort(A, i, p-1);
    Array.prototype._quicksort(A, p+1, j);
}

Array.prototype.quickSort = function () {
    Array.prototype._quicksort(this, 0, this.length-1);
    return this;
};

var A = [ 1, 10, 6, 2, 8, 5, 4, 3, 7, 9 ];
console.log( A.quickSort() );