关于javascript:快速排序JS实现

12次阅读

共计 1972 个字符，预计需要花费 5 分钟才能阅读完成。

疾速排序的根本思维是抉择数组中的一个元素作为关键字，通过一趟排序，把待排序的数组分成两个局部，其中右边的局部比所有关键字小，左边的局部比所有关键字大。而后再别离对左右两边的数据作此反复操作，直到所有元素都有序，就失去了一个齐全有序的数组。

来看一个例子，以数组 [4, 5, 2, 7, 3, 1, 6, 8] 为例，咱们选中数组最右边的元素为关键字 pivot

第一步从右侧开始，往左挪动右指针，遇到 8，6，都比 4 大，直到遇到 1，比 4 小，故把 1 挪动到最右边。右指针放弃不动，开始挪动左指针。

挪动左指针，发现 5 比关键字 pivot 4 大，所以把 5 挪动到方才记录的右指针的地位，相当于把比 pivot 大的值都挪动到右侧。而后开始挪动右指针。

挪动右指针，发现 3 比 pivot 小，故把 3 挪动到方才左指针记录的地位，开始挪动左指针。

挪动左指针，2 比 pivot 小，再挪动，发现 7，7 比 pivot 大，故把 7 放到右指针记录的地位，再次开始挪动右指针。

挪动右指针，发现两个指针重叠了，将 pivot 的值插入指针地位（相当于找到了 pivot 在排序实现后所在的确切地位）。此次排序完结。

一趟排序完结后，将重叠的指针地位记录下来，别离对左右两侧的子数组持续下面的操作，直到宰割成单个元素的数组。所有操作实现之后，整个数组也就变成有序数组了。

动态图如下，动态图应用 20 个元素的无序数组来演示。其中灰色背景为以后正在排序的子数组，橙色为以后 pivot，为不便演示，应用替换元素的形式体现指针地位。

代码如下：

const quickSort = (array)=>{quick(array, 0, array.length - 1)
}

const quick = (array, left, right)=>{if(left < right){let index = getIndex(array, left, right);
    quick(array, left, index-1)
    quick(array, index+1, right)
  }
}

const getIndex = (array, leftPoint, rightPoint)=>{let pivot = array[leftPoint];
  while(leftPoint < rightPoint){while(leftPoint < rightPoint && array[rightPoint] >= pivot) {rightPoint--;}
    array[leftPoint] = array[rightPoint]
    // swap(array, leftPoint, rightPoint)   // 应用 swap，则与动态图演示成果完全一致
    while(leftPoint < rightPoint && array[leftPoint] <= pivot) {leftPoint++;}
    array[rightPoint] = array[leftPoint]
    // swap(array, leftPoint, rightPoint)
  }
  array[leftPoint] = pivot
  return leftPoint;
}

const swap = (array, index1, index2)=>{var aux = array[index1];
  array.splice(index1, 1, array[index2])
  array.splice(index2, 1, aux)
}

const createNonSortedArray = (size)=>{var array = new Array();
  for (var i = size; i > 0; i--) {//array.push(parseInt(Math.random()*100));
    array.push(i*(100/size));
    array.sort(function() {return (0.5-Math.random());
    });
  }
  return array;
}

var arr = createNonSortedArray(20);
quickSort(arr)
console.log(arr)    
//[5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100]

疾速排序很显著用了分治的思维，关键在于抉择的 pivot，如果每次都能把数据平分成两半，这样递归树的深度就是 logN，这样快排的工夫复杂度为 O(NlogN)。
而如果每次 pivot 把数组分成一部分空，一部分为所有数据，那么这时递归树的深度就是 n -1，这样工夫复杂度就变成了 O(N^2)。

依据以上的工夫复杂度剖析，咱们发现如果一个数据齐全有序，那么应用咱们下面的疾速排序算法就是最差的状况，所以怎么抉择 pivot 就成了优化疾速排序的重点了，如果持续应用下面的算法，那么咱们能够随机抉择 pivot 来代替数组首元素作为 pivot 的形式。

正文完