前端几种重要的排序算法

1.快排

//选一个数比它小的放左边，比它小的放右边，递归
var quickSort = function(arr) {
　　if (arr.length <= 1) { return arr; }
　　var 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 quickSort(left).concat([pivot], quickSort(right));
};

2.插入排序

1）从第一个元素开始，该元素可以被认为已经被排序
2）取出下一个元素，在已经排好序的序列中从后往前扫描
3）直到找到小于或者等于该元素的位置
4）将该位置后面的所有已排序的元素从后往前依次移一位
5)将该元素插入到该位置
6)重复步骤2~5
var arr = [4,3,6,1,3,7]
     function insertSort(arr) {
        for (var i=1;i<arr.length; i++) {
            var j=i-1;//默认已排序的元素
            while (j>=0 && arr[j]>arr[i]) {  //在已排序好的队列中从后向前扫描
                    arr[j+1]=arr[j]; //已排序的元素大于新元素，将该元素移到下一个位置
                    j--;
                }
            arr[j+1]=arr[i];
            }
        return arr
     }
	console.log(insertSort(arr))

3.堆排序

function heapSort(A) {
  // 初始化大顶堆，从第一个非叶子结点开始
  for(let i = Math.floor(A.length/2-1); i>=0; i--) {
    shiftDown(A, i, A.length);
  }
  // 排序，每一次for循环找出一个当前最大值，数组长度减一
  for(let i = Math.floor(A.length-1); i>0; i--) {
    swap(A, 0, i); // 根节点与最后一个节点交换
    shiftDown(A, 0, i); // 从根节点开始调整，并且最后一个结点已经为当前最大值，不需要再参与比较，所以第三个参数为 i，即比较到最后一个结点前一个即可
  }
}
// 将 i 结点以下的堆整理为大顶堆，注意这一步实现的基础实际上是：假设 结点 i 以下的子堆已经是一个大顶堆，shiftDown函数实现的功能是实际上是：找到结点 i 在包括结点 i 的堆中的正确位置。
//后面将写一个 for 循环，从第一个非叶子结点开始，对每一个非叶子结点都执行 shiftDown操作，所以就满足了结点 i 以下的子堆已经是一大顶堆
function shiftDown(A, i, length) {
  let temp = A[i]; // 当前父节点
	console.log("i1",i)
  for(let j = 2*i+1; j<length; j = 2*j+1) {  // j = 2*j+1 的目的是，一次堆整理后对结点 i 以下的结点全部做顺序调整
    temp = A[i];  // 将 A[i] 取出，整个过程相当于找到 A[i] 应处于的位置
    if(j+1 < length && A[j] < A[j+1]) { 
		j++;   // 找到两个孩子中较大的一个，再与父节点比较  //右孩子大，把j换成右孩子
	console.log("j1",j)
    }
    if(temp < A[j]) {
      swap(A, i, j) // 如果父节点小于子节点:交换；否则跳出
      i = j;  // 交换后，temp 的下标变为 j
	console.log("i2",i)
	console.log("j2",j)
    } else {
      break;
    } 
  }
}
// 交换两个节点
function swap(A, i, j) {
  let temp = A[i];
  A[i] = A[j];
  A[j] = temp; 
}
let Arr = [0,1,2,3,4];
heapSort(Arr);
console.log(Arr);

4.选择排序

function selectionSort(arr) {
    var min,temp;
    for (var i = 0; i < arr.length - 1; ++i) {
        min = i;
        for (var j = i + 1; j < arr.length; ++j) {
            if (arr[j] < arr[min]) {
                min = j;
            }
        }
        temp = arr[min];
        arr[min] = arr[i];
        arr[i] = temp;
		console.log("第"+i+"次"+arr[min])
    }
    return arr;
}

5.桶排、归并排序

桶排

1.设置固定空桶数a
2.将数据放到对应的空桶中
找到数组中的最大值max和最小值min，然后根据桶数为a，计算出每个桶中的数据范围为(max-min+1)/a=average
遍历原始数据，(以第一个数据first为例)先找到该数据对应的桶序列Math.floor(first - min) / average) =sequence，然后将该数据放入序列为1的桶中(从0开始算)
当向同一个序列的桶中第二次插入数据时，判断桶中已存在的数字与新插入的数字的大小，按从左到右，从小打大的顺序插入。如第一个桶已经有了first，再插入second，third后，桶中的排序为(first，second，third) 一般通过链表来存放桶中数据，但js中可以使用数组来模拟
3.全部数据装桶完毕后，按序列，从小到大合并所有非空的桶(如0,1,2,3,4桶),合并完之后就是已经排完序的数据
4.将每个不为空的桶进行排序
5.拼接不为空的桶中的数据，得到结果

归并排序

归并排序采用的是分治的思想，首先是“分”，将一个数组反复二分为两个小数组，直到每个数组只有一个元素；其次是“治”，从最小数组开始，两两按大小顺序合并，创建一个临时数组C，比较A[0]，B[0]，将较小值放到C[0]，再比较A[1]与B[0]（或者A[0]，B[1]），将较小值放到C[1]，直到对A，B都遍历一遍。可以看出数组A，B都只需遍历一遍，直到并为原始数组大小

6.冒泡

//思路：先比较一轮一次，然后用for循环比较一轮多次，然后再加for循环比较多轮多次
 //从大到小排序
var array=[10,20,9,8,79,65,100];
//比较轮数
for ( var i=0;i<array.length-1;i++){
//每轮比较次数，次数=长度-1-此时的轮数
for (var j=0;j<array.length-1-i;j++) {
if (array[j] > array[j + 1]) {
var temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
} //end if
}//end for 次数
} //end for 轮数
console.log(array);