javascript中的快速排序

我有这个工作插入排序javascript代码

Array.prototype.insertionSort = function() {  
  var A = this; 
  var time = 0;                                
  var n = A.length;
  for (var i = 1; i < n; i++) {
    var v = A[i];
    var j = i-1;
    while (j >= 0 && A[j] > v) {
      A[j+1] = A[j];
      j--; 
      var temp = new Array(this);
      setTimeout(callback(JSON.stringify(temp)), 500*(time++));
    }
    A[j+1] = v;
    var temp = new Array(this);
    setTimeout(callback(JSON.stringify(temp)), 500*(time++));
  }
  return time;
}

Array.prototype.insertionSort=function（）{
var A=此；
var时间=0；
var n=A.长度；
对于（变量i=1；i=0&&A[j]>v）{
A[j+1]=A[j]；
j--；
var temp=新阵列（此）；
setTimeout（回调（JSON.stringify（temp）），500*（time++）；
}
A[j+1]=v；
var temp=新阵列（此）；
setTimeout（回调（JSON.stringify（temp）），500*（time++）；
}
返回时间；
}

我需要类似的quciksort，但我不知道怎么做。有人能帮帮我吗？

这本书非常全面，甚至包含了一些伪代码实现

维基百科对这个问题的总结如下：

快速排序是一种分而治之的算法。快速排序首先将 大数组分为两个较小的子数组：低元素和高元素 元素。然后，快速排序可以对子数组进行递归排序

这些步骤是：

从数组中拾取一个称为轴的元素

分区：对数组进行重新排序，使值小于枢轴的所有元素位于枢轴之前，而值大于枢轴的所有元素位于枢轴之后（两种方式都可以使用相同的值）。在该分区之后，轴心处于其最终位置。这称为分区操作

递归地将上述步骤应用于具有较小值的元素子数组，并分别应用于具有较大值的元素子数组

递归的基本情况是大小为0或1的数组，它们根据定义是有序的，因此它们永远不需要排序

枢轴选择和分区步骤可以分为几个步骤 不同的方式；具体实施方案的选择大大降低了成本 影响算法的性能

---

提醒一下，我记得我在学校做这个问题时，一个接一个的错误是最让我头疼的问题，所以如果你没有马上得到正确的答案，仔细检查您的轴心选择和分区逻辑。

在发布问题之前，您应该检查一下谷歌：快速排序是一种非常常见的算法，您有大量的资源来描述它

function swap(items, firstIndex, secondIndex){
    var temp = items[firstIndex];
    items[firstIndex] = items[secondIndex];
    items[secondIndex] = temp;
}


function partition(items, left, right) {

    var pivot   = items[Math.floor((right + left) / 2)],
        i       = left,
        j       = right;


    while (i <= j) {

        while (items[i] < pivot) {
            i++;
        }

        while (items[j] > pivot) {
            j--;
        }

        if (i <= j) {
            swap(items, i, j);
            i++;
            j--;
        }
    }

    return i;
}


function quickSort(items, left, right) {

    var index;

    if (items.length > 1) {

        left = typeof left != "number" ? 0 : left;
        right = typeof right != "number" ? items.length - 1 : right;

        index = partition(items, left, right);

        if (left < index - 1) {
            quickSort(items, left, index - 1);
        }

        if (index < right) {
            quickSort(items, index, right);
        }

    }

    return items;
}

// first call
var result = quickSort(items);

功能交换（项目、第一索引、第二索引）{
var temp=项目[firstIndex]；
项目[第一索引]=项目[第二索引]；
项目[第二索引]=临时；
}
功能分区（项目、左、右）{
var pivot=项目[数学楼层（（右+左）/2）]，
i=左，
j=右；
而（我）{
j--；
}
如果（i）1{
左=左的类型！=“编号”？0:左；
右=右的类型！=“数字”？项。长度-1：右；
索引=分区（项目、左、右）；
如果（左<索引-1）{
快速排序（项目，左侧，索引-1）；
}
如果（索引<右）{
快速排序（项目、索引、右侧）；
}
}
退货项目；
}
//第一个电话
var结果=快速排序（项目）；

代码学分：

---

此外，请注意，V8在对数组>10项（）调用Array.prototype.sort（）时使用了快速排序。在较小的数组上，InsertionShort实际上更快。

这里有一个用纯JS编写的快速排序的简短版本

如图所示

var分区=功能（arr、低、高）{
var x=arr[高]
变量i=低-1
对于（var j=low；j这可能是延迟发布，但我希望这可能会对某些人有所帮助。快速排序是一种分而治之的算法。它选择一个元素作为轴心，并围绕所选轴心对给定数组进行分区。您可以通过以下方式选择轴心。
a）选择第一个元素作为轴心（在下面实现）b）选择最后一个元素作为轴心c）选择一个随机元素作为轴心。d）选择中间值作为轴心。
如果您的数组已经排序，那么时间复杂度将是O（n^2），但对于平均和最佳情况，时间复杂度是O（n logn）。它是就地算法且不稳定（就像一个远程交换中的分区一样）。在某些情况下，快速排序可能需要二次时间。即使对于大小小于10-20的小数组，快速排序也会带来更大的开销。如果对小数组使用插入排序，则可能会减少15-20%的处理时间。下面分享我的代码，如果您想减少更多的处理时间，请尝试估计分区元素t是数组的中间


类快速排序{
构造函数（）{
这1.2=10；
}
分区（arr、lo、hi）{
设i=lo，j=hi+1；
调试器；
while（true）{
当（i==hi）中断时，（arr[++i]=j）断裂；
本.互换（arr，i，j）；
}
本.掉期（arr、lo、j）；
返回j；
}
交换（arr、i、j）{
设温度=arr[i]；
arr[i]=arr[j]；
arr[j]=温度；
}
排序（arr、lo、hi）{
//如果（hi=hi）{
让insertionSort=新建insertionSort（）；
insertionSort.sort（arr）；返回；
}
log（“内部快速排序”）；
设j=this.partition（arr，lo，hi）；
该类（arr、lo、j-1）；
这个.sort（arr，j+1，hi）；
}
洗牌（arr）{
设n=arr.length；
for（设i=0；i0；j--）{
如果（arr[j-1]>arr[j]）{
这个.quickSort.swap（arr，j，j-1）；
}
}
}    
}
}
设arr=[101,22,4,22,2,7,9,10,49101，-1,4,1,6,99]；
log（'排序数组之前'）；
控制台日志（arr）；
让快速排序=新建快速排序（）；
快速排序。洗牌（arr）；
log（'对数组排序后'）；
欺骗
var partition = function (arr, low, high) {
    var x = arr[high]
    var i = low - 1
    for (var j = low; j <= high - 1; j++) {
        if (arr[j] <= x) {
            i++
            var temp = arr[i]
            arr[i] = arr[j]
            arr[j] = temp
        }
    }
    var temp = arr[i + 1]
    arr[i + 1] = arr[high]
    arr[high] = temp
    return i + 1 
}

var quickSort = function (arr, low, high) {
    if (low < high) {
        index = partition(arr,low,high)
        if (low < index-1) quickSort(arr,low,index-1)
        if (index+1 < high) quickSort(arr,index+1,high)
    }
}

var list2 = [1000,13,12,1001,82,1,2,4,3,0]

console.log(quickSort(list2,0,list2.length))