1、冒泡排序
两两比较待排序的关键字,并交换不满足次序要求的那对数,直到整个表都满足次序要求为止。
bubbleSort = (list) = > {
let temp = 0; // 用来交换的临时数
// 要遍历的次数
for (let i = 0; i < list.length - 1; i++) {
// 从后向前依次的比较相邻两个数的大小,遍历一次后,把数组中第i小的数放在第i个位置上
for (let j = list.length - 1; j > i; j--) {
// 比较相邻的元素,如果前面的数大于后面的数,则交换
if (list[j - 1] > list[j]) {
temp = list[j - 1];
list[j - 1] = list[j];
list[j] = temp;
}
}
}
}
冒泡排序算法的性能
若文件的初始状态是正序的,一趟扫描即可完成排序。所需的关键字比较次数C和记录移动次数M均达到最小值:Cmin = N - 1。所以,冒泡排序最好时间复杂度为O(N)。
若初始文件是反序的,需要进行 N -1 趟排序。每趟排序要进行 N - i 次关键字的比较(1 ≤ i ≤ N - 1),且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下,比较和移动次数均达到最大值:
Cmax = N(N-1)/2 = O(N2)
Mmax = 3N(N-1)/2 = O(N2)
冒泡排序的最坏时间复杂度为O(N2)。
因此,冒泡排序的平均时间复杂度为O(N2)。
算法稳定性:相同元素的前后顺序并没有改变,所以冒泡排序是一种稳定排序算法。
2、选择排序
两两比较待排序的关键字,并交换不满足次序要求的那对数,直到整个表都满足次序要求为止。
function selectSort(nums){
let n = nums.length;
let minIndex,temp;
for(let i=0;i<n-1;i++){
minIndex = i;
for(let j=i+1;j<n;j++){
if(nums[minIndex]>nums[j]){
minIndex = j;
}
}
temp = nums[i];
nums[i] = nums[minIndex];
nums[minIndex] = temp;
}
return nums;
}
选择排序算法的性能
需要遍历数组才能找到峰值元素,所以复杂度与原始序列是否有序无关:
Cmax = n + n-1 + n-2 + … + 2 + 1 = n * (n+1) / 2 = O(N2)
冒泡排序的时间复杂度为O(N2)。
因此,冒泡排序的平均时间复杂度为O(N2)。
算法稳定性:无序部分最大元素和有序部分第一个元素相等的时候,可以将无序部分最大元素放在前面,所以选择排序是稳定的。
3、插入排序
将未排序数据,对已排序数据序列从后向前扫描,找到对应的位置并插入。在从后向前扫描的过程中,需要反复的把已排序的元素逐步向后挪位,为新插入元素提供插入的位置。
function insertSort(arr) {
var len =arr.length;
for (var i=1;i<len; i++) {
var temp=arr[i];
var j=i-1;//默认已排序的元素
while (j>=0 && arr[j]>temp) { //在已排序好的队列中从后向前扫描
arr[j+1]=arr[j]; //已排序的元素大于新元素,将该元素移到一下个位置
j--;
}
arr[j+1]=temp;
}
return arr;
}
插入排序算法的性能
如果目标是升序排序,那么插入排序有最好情况和最坏情况两种。最好情况是,序列已经是升序排列,那么只需要比较n-1次,当序列是降序排列,那么比较次数是n(n-1)/2,赋值操作是比较次数减去(n-1)次。平均来说,插入算法时间复杂度是O(n^2),空间复杂度是O(1)。
算法稳定性:无序部分最大元素和有序部分第一个元素相等的时候,可以将无序部分最大元素放在前面,所以插入排序是稳定的。
4、快速排序
数组中指定一个元素作为标尺,比它大的放到该元素后面,比它小的放到该元素前面,如此重复直至全部正序排列。它利用了“分治”思想——把一个复杂的问题分成两个或更多的相同或相似的子问题,直到最后子问题可以简单的直接求解,原问题的解即子问题的解的合并。
let QuickSort = (arr, low, high) => {
let temp;
let i = low;
let j = high;
if (low < high) {
temp = R[low]; //设置枢轴
while (i !== j) {
while (j > i && R[j] >= temp) {
--j;
}
if (i < j) {
R[i] = R[j];
++i;
}
while(i < j && R[i] < temp) {
++i;
}
if (i < j) {
R[j] = R[i];
--j;
}
}
R[i] = temp;
QuickSort(R, low, i-1);
QuickSort(R, i+1, high);
}
}
快速排序算法的性能
时间复杂度: 快速排序最优的情况就是每一次取到的元素都刚好平分整个数组,根据递归算法的时间复杂度公式:T[n] = aT[n/b] + f(n) ,得到快速排序最优的情况下时间复杂度为:O( nlogn ) ;最差的情况就是每一次取到的元素就是数组中最小/最大的,这种情况其实就是冒泡排序了,所以时间复杂度为O(n2),平均时间复杂度为O(nlog2n)。快速排序不是稳定排序。