JS常见算法

最常见的排序和搜索算法，如冒泡排序，选择排序，插入排序，希尔排序，归并排序，快速排序，桶排序，计数排序，基数排序，顺序排序，内插排序和二分搜索排序，简单介绍下面几种排序：

1.冒泡排序

冒泡排序是所有排序中最简单的，但是也是时间复杂度最高的 O(n^2)。冒泡排序比较所有相邻的两个项，如果第一个比第二个大，则交换它们。元素项向上移动至正确的顺序，就好像气泡升至表面一样，冒泡排序因此得名。

看下代码：

function bubbleSort(array, compareFn = defaultCompare){
   const { length } = array;
   for(let i = 0; j < length; i++){
        for(let j = 0; j < length -1; j++){
            if(compareFn(array[j], array[j + 1]) === Compare.BIGGER_THAN){
               swap(arry, j, j + 1)
            }
        }
   } 
   return array}

非分布式排序都会接受一个待排序的数组作为参数以及一个比较函数，defaultCompare函数（return  a < b ? Compare.LESS_THAN : Compare.BIGGER_THAN）

function swap(array, a, b){   [ array[a], array[b] ] = [ array[b], array[a] ]}

改进后的冒泡排序

function modifiedBubbleSort( array, compareFn = defaultCompare){   
     const {  length } = array;  
      for(let i = 0; j < length; i++){       
         for(let j = 0; j < length -1 - i; j++){
            if(compareFn(array[j], array[j + 1]) === Compare.BIGGER_THAN){
               swap(arry, j, j + 1)
            }
         }
     }
    return array
}

2.归并排序

归并排序是第一个使用到实际中的排序算法，复杂度为O(nlog(n)).其中Mozilla Firefox使用归并排序作为Array.prototype.sort的实现，而Chrome(v8引擎)使用的是一个快速排序的变体。归并排序是一种分而治之算法，其思想就是将原始数组切分成较小的数组，直至每个小数组只有一个位置，接着将小数组归并成较大的数组，直到最后只有一个排序完毕的大数组。

function mergeSort(array, compareFn = defaultCompare){    
   if(array.length > 1){       
       const {  length } = array;  
       const middle = Math.floor(length / 2);
       const left = mergeSort(array.slice(0, middle), compareFn);
       const right = mergeSort(array.slice(middle, length), compareFn);        array = merge(left, right, compareFn);
     }
    return array
}

function merge(left, right, compareFn){   
    let i = 0;   
    let j = 0;   
    const result = [];
    while(i < left.length && j < right.length){
        result.push(compareFn(left[i], right[j]) === Compare.LESS_THAN ? left[i++] : right[j++])
   }
    return result.concat(i < left.length ? left.slice(i) : right.slice(j))
}