1.冒泡排序

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

function bSort(arr) {
  var len = arr.length;
  for (var i = 0; i < len-1; i++) {
    for (var j = 0; j < len - 1 - i; j++) {
         // 相邻元素两两对比，元素交换，大的元素交换到后面
        if (arr[j] > arr[j + 1]) {
            var temp = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = temp;
        }
    }
  }
  return arr;
}

2.选择排序

function selectionSort(arr) {
    var len = arr.length;
    var minIndex, temp;
    for (var i = 0; i < len - 1; i++) {
        minIndex = i;
        for (var j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {     //寻找最小的数
                minIndex = j;                 //将最小数的索引保存
            }
        }
        temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
    return arr;
}

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

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
     }

每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

4.归并排序

将两个顺序序列合并成一个顺序序列的方法。

function mergeSort(arr) {
    // 序列长度为1时退出
    if (arr.length < 2 ) {
        return arr
    }

    // 将序列分为两个子序列，这一块用到“分治法”中的“分割”
    const middle = Math.floor(arr.length/2)
    const left = arr.slice(0, middle)
    const right = arr.slice(middle)

    // 递归，这一块用到“分治法”中的“集成（合并）”
    return merge(mergeSort(left), mergeSort(right))
}

function merge(left, right) {
    const result = []

    // 两个子序列进行比较，从小到大放入新的序列result中
    while(left.length > 0 && right.length > 0) {
        // 将较小的放入result,并改变left或者right的长度，灵活使用shift方法
        if (left[0] < right[0]) {
            result.push(left.shift())
        } else {
            result.push(right.shift())
        }
    }

    // 先将小的元素放入result中，直到left或者right为空，剩余的一个数组肯定是大于result的有序序列，所以直接通过concat进行合并返回
    return result.concat(left, right)
}

5.快速排序

首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。

function quickSort(arr){
            //如果数组<=1,则直接返回
            if(arr.length<=1){return arr;}
            var pivotIndex=Math.floor(arr.length/2);
            //找基准，并把基准从原数组删除
            var pivot=arr.splice(pivotIndex,1)[0];
            //定义左右数组
            var left=[];
            var right=[];

            //比基准小的放在left，比基准大的放在right
            for(var i=0;i<arr.length;i++){
                if(arr[i]<=pivot){
                    left.push(arr[i]);
                }
                else{
                    right.push(arr[i]);
                }
            }
            //递归
            return quickSort(left).concat([pivot],quickSort(right));
        }

6.sort()排序

传入参数，实现升序，降序；

var arr3 = [30,10,111,35,1899,50,45];
	arr3.sort(function(a,b){
		return a - b;
	})
	console.log(arr3);//输出  [10, 30, 35, 45, 50, 111, 1899]
	
	var arr4 = [30,10,111,35,1899,50,45];
	arr4.sort(function(a,b){
		return b - a;
	})
	console.log(arr4);//输出 [1899, 111, 50, 45, 35, 30, 10]

各种排序的速度性能（10万数据）

1.快速排序
cutoff5—>30-50ms
cutoff10 —>30-60ms
cutoff50 ---->40-50ms
cutoff3效果不错—>30-50ms，30ms出现的机会很多
cutoff==0时（即不在分割长度短的时候转为插入排序），效果依然不错，30-50ms，30ms出现的很多

2.sort排序 55-70ms

3.归并排序耗时80-100ms

4.选择排序耗时5800ms左右

5.插入排序耗时10600ms左右

6.冒泡排序耗时26000ms左右

疫情之下，信息的交流尤为重要，快速便捷的获取防控信息能让我们更加合理的安排工作和出行，近期发现了一款宝藏小程序，让我们便捷的进行信息交流，给大家安利一下，让我们一起打赢这场疫情攻坚战