前端常见的排序算法
1、冒泡排序
- 比较相邻的两个元素。如果第一个比第二个大，则交换位置；
- 对每一对相邻元素重复第一个步骤，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
- 针对所有的元素重复以上的步骤，除了最后一个；
- 重复步骤1~3，直到排序完成。
/**
* 外循环控制需要比较的元素，比如第一次排序后，
最后一个元素就不需要比较了，内循环则负责两两元素比较，将元素放到正确位置上
*/
function bubbleSort(arr) {
const len = arr.length
for(let i=0; i arr[j+1]){
[arr[j],arr[j+1]] = [arr[j+1],arr[j]] // 交换位置
}
}
}
return arr
}
console.log(bubbleSort([3,44,15,36,26,27,2,46,4,19,50,48]))
//[2,3,4,15,19,26,27,36,44,46,48,50] 时间复杂度：O(n^2)
2、快速排序
-
选择一个参考元素，将列表分割成两个子序列；
-
对列表重新排序，将所有小于基准值的元素放在基准值前面，所有大于基准值的元素放在基准值的后面；
-
分别对较小元素的子序列和较大元素的子序列重复步骤1和2
function quickSort(arr) {
if(arr.length<=1) return arr
const left = [],right = [],current = arr.splice(0,1)
for(let i=0; i时间复杂度：O(nlogn)
3、插入排序
-
从第一个元素开始，该元素可以认为已经被排序；
-
取出下一个元素，在已经排序的元素序列中从后向前扫描；
-
如果该元素（已排序）大于新元素，将该元素移到下一位置；
-
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
-
将新元素插入到该位置后；
-
重复步骤2~5。
/**双层循环，外循环控制未排序的元素，内循环控制已排序的元素，将未排序元素设为标杆，
与已排序的元素进行比较，小于则交换位置，大于则位置不动
*/
function insertSort(arr) {
let tem
for(let i=0; i=0; j--){
if(arr[j-1] > tem){
arr[j] = arr[j-1]
}else {
arr[j] = tem
break
}
}
}
return arr
}
console.log(insertSort([3,44,15,36,26,27,2,46,4,19,50,48]))
//[2, 3, 4, 15, 19, 26, 27, 36, 44, 46, 48, 50] 时间复杂度O(n^2)
4、选择排序
-
初始状态：无序区为R[1..n]，有序区为空；
-
第i趟排序(i=1,2,3...n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
-
n-1趟结束，数组有序化了。
/**
* 先假设第一个元素为最小的，然后通过循环找出最小元素，
* 然后同第一个元素交换，接着假设第二个元素，重复上述操作即可
*/
function selectSort(arr) {
let len = arr.length, minIndex, tem
for(let i=0; i时间复杂度O(n^2)
5、归并排序
- 把长度为n的输入序列分成两个长度为n/2的子序列；
- 对这两个子序列分别采用归并排序；
- 将两个排序好的子序列合并成一个最终的排序序列。
// 将数组一直等分，然后合并
function merge(left, right) {
let tem = []
while(left.length && right.length) {
if(left[0] < right[0]) {
tem.push(left.shift())
}else{
tem.push(right.shift())
}
}
return tem.concat(left,right)
}
function mergeSort(arr) {
const len = arr.length
if(len<2) return arr
let mid = Math.floor(len / 2), left = arr.slice(0,mid), right = arr.slice(mid)
return merge(mergeSort(left),mergeSort(right))
}
console.log(mergeSort([3,44,15,36,26,27,2,46,4,19,50,48]))
// [2, 3, 4, 15, 19, 26, 27, 36, 44, 46, 48, 50]时间复杂度O(nlogn)
6、希尔排序
- 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
- 按增量序列个数k，对序列进行k 趟排序；
- 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
function shellSort(arr) {
var len = arr.length;
for(var gap = Math.floor(len / 2); gap > 0; gap = Math.floor(gap / 2)) {
for(var i = gap; i < len;i++) {
var j = i;
var current = arr[i];
while (j - gap >= 0 && current < arr[j - gap]) {
arr[j] = arr[j - gap];
j = j - gap;
}
arr[j] = current;
}
}
return arr;
}
console.log(shellSort([50,70,60,80,61,84,83,88,87,99]))
//[50, 60, 61, 70, 80, 83, 84, 87, 88, 99]时间复杂度：O(nlogn)
转载于：https://juejin.cn/post/7073640285904830471