前言：
（1）排序的定义：对一序列对象根据某个关键字进行排序；
输入：n个数：a1,a2,a3,...,an
输出：n个数的排列:a1',a2',a3',...,an'，使得a1'<=a2'<=a3'<=...<=an'。
再讲的形象点就是排排坐，调座位，高的站在后面，矮的站在前面。
（2）对于评述算法优劣术语的说明
稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；
不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；
内排序：所有排序操作都在内存中完成；
外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
时间复杂度: 一个算法执行所耗费的时间；
空间复杂度: 运行完一个程序所需内存的大小。
（3）排序算法总结
n: 数据规模
k:“桶”的个数
In-place: 占用常数内存，不占用额外内存
Out-place: 占用额外内存
1、冒泡排序（Bubble Sort）
（1）算法描述：
从数组开头开始遍历，需要遍历数组长度的次数。每一次遍历，依次比较相邻的两个元素，如果它们的顺序错误就进行交换。每一次遍历完成就会排好一个最大数或者最小数
（2）代码实现：
function bubbleSort(arr) {
if(!arr || arr.length < 2)
return;
for (let end=arr.length-1; end>0; end--) { // 每次循环都会排好一个最大数
for (let j=0; j<end; j++) {
if (arr[j] > arr[j+1]) {
let temp = arr[j+1];
arr[j+1] = arr[j];
arr[j] = temp;
}
}
}
return arr;
}（3）性能分析：
- 最佳性能：T(n) = O(n) 当输入的数据为正序时
- 最差性能：T(n) = O(n^2) 当输入的数据为反序时
2、选择排序（Selection Sort）
（1）算法描述：
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾
（2）代码实现：
function selectionSort(arr) {
if (!arr || arr.length < 0)
return;
let len = arr.length;
for (let i=0; i<len-1; i++) {
let minIndex = i;
for (let j=i+1; j<len; j++) {
arr[j] < arr[minIndex] ? j : minIndex;
}
swap(arr[i], arr[minIndex]) // 交换两个数，将本次循环找到的最小数排到前面
}
}（3）性能分析：
- 最佳情况：T(n) = O(n^2)
- 最差情况：T(n) = O(n^2)
- 平均情况：T(n) = O(n^2)
3、插入排序
（1）算法描述：
从第一个元素开始，认为该元素已经排序，然后取下一个元素，在已排序序列中从后往前扫描，找到合适的位置插入
（2）代码实现：
function insertSort(arr) {
if (!arr || arr.length < 2)
return;
let len = arr.length;
for (let i = 1; i < len; i++) {
for (let j=i-1; j>0 && arr[j]>arr[j+1]; j--) { // 一直循环有序区，知道前面的数小于当前的数，则停止交换
swap(arr[j], arr[j+1]);
}
}
return arr;
}改进插入排序：在寻找插入位置的时候，可以使用二分查找的方法。
（3）性能分析：
- 最佳情况：输入数组按升序排列。T(n) = O(n)
- 最坏情况：输入数组按降序排列。T(n) = O(n^2)
- 平均情况：T(n) = O(n^2)
4、希尔排序
（1）算法描述：
将整个带排序的序列数组分割成为若干子序列，然后分别对于子序列进行插入排序
（2）代码实现：
function shellSort(arr) {
let len = arr.length;
let temp;
let gap = 1;
while(gap < len/5) { //动态定义间隔序列
gap = gap*5+1;
}
for (gap; gap > 0; gap = Math.floor(gap/5)) {
for (let i = gap; i < len; i++) {
temp = arr[i];
for (let j = i-gap; j >= 0 && arr[j] > temp; j-=gap) {
arr[j+gap] = arr[j];
}
arr[j+gap] = temp;
}
}
return arr;
}（3）性能分析：
- 最佳情况：T(n) = O(nlog2 n)
- 最坏情况：T(n) = O(nlog2 n)
- 平均情况：T(n) =O(nlog n)
5、归并排序
（1）算法描述：
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
（2）代码实现：
function mergeSort(arr) { //采用自上而下的递归方法
let len = arr.length;
if(len < 2) {
return arr;
}
let middle = Math.floor(len / 2);
let left = arr.slice(0, middle);
let right = arr.slice(middle);
return merge(mergeSort(left), mergeSort(right));
}
function merge(left, right)
{
let result = [];
while (left.length && right.length) {
if (left[0] <= right[0]) {
result.push(left.shift());
} else {
result.push(right.shift());
}
}
while (left.length)
result.push(left.shift());
while (right.length)
result.push(right.shift());
return result;
}改进：指定范围的归并排序，且优化空间复杂度，返回结果是排序后的原数组而不是新的数组
function mergeSort (arr) {
if (!arr || arr.length < 2) {
return arr;
}
sortProcess(arr, 0, arr.length - 1);
}
function sortProcess (arr, leftIndex, rightIndex) {
if (leftIndex === rightIndex) {
return arr[leftIndex];
}
let middle = leftIndex + ((rightIndex - leftIndex) >> 1);
sortProcess(arr, leftIndex, middle);
sortProcess(arr, rightIndex, middle);
merge(arr, leftIndex, middle, rightIndex);
}
function merge (arr, leftIndex, middle, rightIndex) {
let p1 = leftIndex, p2 = middke + 1, i=0;
let result = [];
while (p1<=middle && p2<=rightIndex) {
if (arr[p1] < arr[p2]) {
result[i++] = arr[p1++];
} else {
result[i++] = arr[p2++];
}
}
// 越界情况
while (p1<=middle) {
result[i++] = arr[p1++];
}
while (p2<=reftIndex) {
result[i++] = arr[p2++];
}
// 将排序后的数组拷贝到原数组
for (i=0; i<result.length; i++) {
arr[leftIndex+i] = result[i]; // leftindex+i 的原因是因为可能指定了排序的范围
}
}（3）性能分析：
- 最佳情况：T(n) = O(n)
- 最差情况：T(n) = O(nlogn)
- 平均情况：T(n) = O(nlogn)
6、快速排序
（1）算法描述：
通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序
（2）代码实现：
function quickSort(array, left, right) {
if (left < right) {
var x = array[right], i = left - 1, temp;
for (var j = left; j <= right; j++) {
if (array[j] <= x) {
i++;
temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
quickSort(array, left, i - 1);
quickSort(array, i + 1, right);
}
return array;
}
//方法二
var quickSort2 = function(arr) {
if (arr.length <= 1) {
return arr;
}
let pivotIndex = Math.floor(arr.length / 2);
var pivot = arr.splice(pivotIndex, 1)[0];
var left = [];
var right = [];
for (var i = 0; i < arr.length; i++){
if (arr[i] < pivot) {
left.push(arr[i]);
} else {
right.push(arr[i]);
}
}
return quickSort2(left).concat([pivot], quickSort2(right));
};function quickSort (arr) {
if (!arr || arr.length < 2) {
return arr;
}
sortProcess(arr, 0, arr.length - 1);
}
function sortProcess (arr, L, R) {
if (L < R) {
swap(arr, Math.floor(Math.random()* (R-L+1), R); // 随机选取一个数作为划分数,并且交换到最后一个位置
let equalPos = partition(arr, L, R); // 以划分数为基准，将数组明确的划分为左侧小于区，右侧大于区
sortProcess(arr, L, equalPos[0]-1);
sortProcess(arr, equalPos[1]+1, R);
}
}
function partition(arr, L, R) {
let less = L-1;
let more = R+1;
let target = arr[R];
while(less < more) {
if (arr[L] < target) {
swap(arr, ++less, L);
L++;
} else if (arr[L] > target) {
swap(arr, --more, L);
} else {
L++;
}
}
return [less+1, more];
}（3）性能分析：
- 最佳情况：T(n) = O(nlogn)
- 最差情况：T(n) = O(n2)
- 平均情况：T(n) = O(nlogn)
7、堆排序
（1）算法描述：
利用堆这种数据结构的特性，将默认的数据构成无序堆，然后调整为大根堆（或者小根堆），将堆顶的数值沉到最后（相当于找出了一个最大值或者最小值）然后接着依次调整，直到排序完成。
（2）代码实现：
/*方法说明：堆排序
@param array 待排序数组
*/
function heapSort(array) {
//建堆
var heapSize = array.length, temp;
for (var i = Math.floor(heapSize / 2) - 1; i >= 0; i--) {
heapify(array, i, heapSize);
}
//堆排序
for (var j = heapSize - 1; j >= 1; j--) {
temp = array[0];
array[0] = array[j];
array[j] = temp;
heapify(array, 0, --heapSize);
}
return array;
}
/*方法说明：维护堆的性质 （递归版本）
@param arr 数组
@param x 数组下标
@param len 堆大小
*/
function heapify(arr, x, len) {
if (Object.prototype.toString.call(arr).slice(8, -1) === 'Array' && typeof x === 'number') {
var left = 2*x+1, right = 2*x+2, largest = x, temp;
if (left < len && arr[left] > arr[largest]) {
largest = left;
}
if (right < len && arr[right] > arr[largest]) {
largest = r;
}
if (largest != x) {
temp = arr[x];
arr[x] = arr[largest];
arr[largest] = temp;
heapify(arr, largest, len);
}
} else {
return 'arr is not an Array or x is not a number!';
}
}
// 非递归版本
function heapify1(arr, index, heapsize) {
let left = 2*index+1;
while(left<heapsize) {
let maxChildIndex = left+1<heapsize && arr[left+1]>arr[left] ? left+1 : left;
let largest = arr[maxChildIndex] > arr[index] ? maxChildIndex : index;
if(largest = index) {
break;
}
swap(arr, largest, index);
index = largest;
left = 2*index+1;
}
}（3）性能分析：
- 最佳情况：T(n) = O(nlogn)
- 最差情况：T(n) = O(nlogn)
- 平均情况：T(n) = O(nlogn)
【注】
扫一扫
167
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
