1.冒泡排序
冒泡排序法又称为交换排序法，是从观察水中气泡变化构思而成。原理是从第一个元素开始，比较相邻元素的大小，若大小顺序有误，则对调后再进行下一个元素的比较。如此经过第一次扫描后就可以确保最后一个元素位于正确的顺序；经过第二次扫描可以确保倒数第二个元素位于正确的顺序。由此可知，N个元素经过（N-1）次扫描，就可以完成所有元素的排序。
//冒泡排序
var arr = [4, 1, 2, 5, 8, 3, 6];
var temp = null;
for (var i = 0; i < arr.length; i++) {
for (var k = 0; k < arr.length - 1; k++) {
if (arr[k] > arr[k + 1]) {
temp = arr[k + 1];
arr[k + 1] = arr[k];
arr[k] = temp;
}
}
}
console.log(arr);
// 冒泡排序的时间的复杂度为N*N
2.快速排序
快速排序（Quick Sort）是由C.A.Hoare所提出来的。快速排序法又称分割交换排序法，是目前公认最佳的排序法，也是使用“分而治之”（Divide and Conquer）的方式，先在数据中找到一个虚拟的中间值，并按此中间值将所有打算排序的数据分为两部分。其中，小于中间值的数据放在左边，大于中间值的数据放在右边，再以同样的方式分别处理左、右两边的数据，直到排序完为止。
快速排序的步骤：
(1) 选择基准值。
(2) 将数组分成两个子数组：小于基准值的元素和大于基准值的元素。
(3) 对这两个子数组进行快速排序。
算法简单描述：选择数组第一位元素位基准值，创建两个新数组，分别存放小于基准值和大于基准值的元素。然后这两个新数组递归进行上述操作，直到数组为空。然后将左右数组和基准值进行拼接。
//快速排序 使用递归 数组折半
var arr1 = [1, 9, 2, 7, 8, 2, 5, 3, 6, 4];
function quickSort(arr) {
if (arr.length <= 1) {
return arr;
}
if (Array.isArray(arr)) {
var center = parseInt(arr.length / 2);
// 取中间值需要让原数组发生变化
var centerNum = arr.splice(center, 1);
var left = [];
var right = [];
for (var i = 0; i < arr.length; i++) {
if (arr[i] <= centerNum) {
left.push(arr[i]);
} else {
right.push(arr[i]);
}
}
//使用递归是快排 每次取中间排完再调用两边重新排序
return quickSort(left).concat(centerNum).concat(quickSort(right));
}
}
console.log(quickSort(arr1));
//快速排序的平均时间复杂度为NlogN；
插入排序
插入排序法（Insert Sort）是将数组中的元素，逐一与已排序好的数据进行比较，前两个元素先排好，再将第三个元素插入适当的位置，所以这三个元素仍然是已排好序的，接着将第四个元素加入，重复此步骤，直到排序完成为止。可以看作是在一串有序的记录R1、R2…Ri中，插入新的记录R，使得i+1个记录排序妥当。
//插入排序；
//原理默认第一个已经排序 取到当前的和之前的比对 如果满足条件 交换位置
var arr2 = [1, 9, 2, 7, 8, 2, 5, 3, 6, 4];
function insertSort(arr) {
if (!Array.isArray(arr)) {
return;
}
for (var i = 0; i < arr.length; i++) {
var nowNum = arr[i]; // 记录当前的值
var prevIndex = i - 1; //前面的索引
//对前面进行判断
while (prevIndex >= 0 && arr[prevIndex] > nowNum) {
//交换位置
arr[prevIndex + 1] = arr[prevIndex];
prevIndex--;
}
arr[prevIndex + 1] = nowNum;
}
console.log(arr);
}
insertSort(arr2);
选择排序
选择排序法（Selecting Sort）也算是枚举法的应用，就是反复从未排序的数列中取出最小的元素，加入到另一个数列中，最后的结果即为已排序的数列。从小到大排序的操作是一开始在所有的数据中挑选一个最小项放在第一个位置，再从第二项开始挑选剩下元素的最小项放在第2个位置，以此反复，直到完成排序为止。由此可知，N个元素经过（N-1）次扫描，就可以完成所有元素的排序。
以上文字叙述和图片来自于原文链接：https://blog.csdn.net/weixin_42575793/article/details/103700006
// 选择型排序
var arr3 = [1, 9, 2, 7, 8, 2, 5, 3, 6, 4];
function selectSort(arr) {
if (!Array.isArray(arr)) {
return;
}
var temp = null;
for (var i = 0; i < arr.length; i++) {
//默认记录最小索引
var minindex = i;
for (var k = i + 1; k < arr.length; k++) {
minindex = arr[k] < arr[minindex] ? k : minindex;
}
//交换位置
temp = arr[i];
arr[i] = arr[minindex];
arr[minindex] = temp;
}
console.log(arr);
}
selectSort(arr3);
5.归并排序
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
1、把长度为n的输入序列分成两个长度为n/2的子序列；
2、对这两个子序列分别采用归并排序；
3、将两个排序好的子序列合并成一个最终的排序序列。
//归并排序
var arr4 = [1, 9, 2, 7, 8, 2, 5, 3, 6, 4];
function mergeSort(arr) {
if (arr.length < 2) {
return arr;
}
//首先将无序数组划分为两个数组
var mid = Math.floor(arr.length / 2);
var left = arr.slice(0, mid);
var right = arr.slice(mid, arr.length);
return merge(mergeSort(left), mergeSort(right)); //递归分别对左右两部分数组进行排序合并
}
//合并
function merge(left, right) {
var result = [];
while (left.length > 0 && right.length > 0) {
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;
}
console.log(mergeSort(arr4));