js排序算法总结

快速排序

大致分三步：

1、找基准（一般是以中间项为基准）

2、遍历数组，小于基准的放在left，大于基准的放在right

3、递归

快速排序的平均时间复杂度是O(nlogn)，最差情况是O(n²)。

代码实现

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));
       //  [...quickSort(left),pivot,...quickSort(right)]   
}

冒泡排序

1、比较相邻的两个元素，如果前一个比后一个大，则交换位置（默认从小到大排序）。
2、比较完第一轮的时候，最后一个元素是最大的元素。
3、这时候最后一个元素是最大的，所以最后一个元素就不需要参与比较大小。

代码实现

function bubble(arr){
    //常规 数组加判断 
    if (arr instanceof Array && arr.length > 1) {
    
    }

    //外层循环，控制趟数，每一次找到一个最大值
    for (var i = 0; i < arr.length - 1; i++) {
        // 内层循环,控制比较的次数，并且判断两个数的大小
        for (var j = 0; j < arr.length - 1 - i; j++) {
            //如果前面的数大，放到后面(当然是从小到大的冒泡排序)
            if (arr[j] > arr[j + 1]) {
                var temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    return arr
}

二分查找

二分查找，也为折半查找。首先要找到一个中间值，通过与中间值比较，大的放又，小的放在左边。再在两边中寻找中间值，持续以上操作，直到找到所在位置为止。

（递归方法）

function binarySearch(arr,dest,start,end){
    var end = end || arr.length-1,
        start=start || 0,
        mid = Math.floor((start+end)/2);
    if(dest==arr[mid]){
        return mid
    }
    if(dest<arr[mid]){
        return binarySearch(arr,dest,0,mid-1)
    }else{
        return binarySearch(arr,dest,mid+1,end)
    }
    return false
}
var arrData =[-34,1,3,4,5,8,34,45,65,87]
console.log(binarySearch(arrData,4))  // 3

（非递归方法）

function binarySearch(arr,dest,start,end){
    var end = end || arr.length-1,start=start || 0;
    while(start<=end){
        var mid=Math.floor((start+end)/2)
        if(dest==arr[mid]){
            return mid
        }
        if(dest>arr[mid]){
            start=mid+1
        }else{
            end=mid-1
        }
    }
    return false
}
var arrData =[-34,1,3,4,5,8,34,45,65,87]
console.log(binarySearch(arrData,4))  // 3

插入排序

（1）从第一个元素开始，该元素可以认为已经被排序

（2）取出下一个元素，在已经排序的元素序列中从后向前扫描

（3）如果该元素（已排序）大于新元素，将该元素移到下一位置

（4）重复步骤3，直到找到已排序的元素小于或者等于新元素的位置

（5）将新元素插入到下一位置中

（6）重复步骤2

function insertSort(arr){
    //假设第0个元素是一个有序的数列，第1个以后的是无序的序列
    //所以从第一个元素开始将无序数列的元素插入到有序数列中
    for (var i = 1; i < arr.length; i++) {
        //升序
        if(arr[i]<arr[i-1]){
            //取出无序数列中的第i个作为被插入的元素
            var temp=arr[i]
            //记住有序数列的最后一个位置，并且将有序数列位置扩大一个
            var j =i-1
            arr[i]=arr[i]
            //比大学，找到被插入元素所在的位置
            while (j>=0 && temp<arr[j]) {
                arr[j+1]=arr[j]
                j--
            }
            arr[j+1]=temp  //插入
        }
    }
    return arr
}

选择排序

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

以此类推，直到所有元素均排序完毕。

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