排序

// 不稳定的排序: 选择排序、快速排序、希尔排序、堆排序
// 稳定排序：冒泡排序、插入排序、归并排序、基数排序
function 冒泡排序(arr){
    let len = arr.length;
    for (let i = 0; i <len; i++) {
        for (let j = 0; j < len-1-i; j++) {
            if (arr[j]> arr[j+1]) {
                var temp = arr[j+1];
                arr[j+1] = arr[j];
                arr[j]  = temp
            }            
        }  
    }
    return arr
}//最好情况:O(n)  最坏情况O(n^2)  平均情况O(n^2)
function 快速排序(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 快速排序(left).concat([pivot],快速排序(right));
}//最好情况:O(nlogn的对数)  最坏情况O(n^2)  平均情况O(nlogn的对数)
function 插入排序(arr) {
    var len = arr.length;
    var preIndex, current;
    for (var i = 1; i < len; i++) {
        preIndex = i - 1;
        current = arr[i];
        while(preIndex >= 0 && arr[preIndex] > current) {
            arr[preIndex+1] = arr[preIndex];
            preIndex--;
        }
        arr[preIndex+1] = current;
    }
    return arr;
}//最好情况:O(n)  最坏情况O(n^2)  平均情况O(n^2)
function 希尔排序(arr) {
    var len = arr.length,
        temp,
        gap = 1;
    while(gap < len/3) {          //动态定义间隔序列
        gap =gap*3+1;
    }
    for (gap; gap> 0; gap = Math.floor(gap/3)) {
        for (var i = gap; i < len; i++) {
            temp = arr[i];
            for (var j = i-gap; j > 0 && arr[j]> temp; j-=gap) {
                arr[j+gap] = arr[j];
            }
            arr[j+gap] = temp;
        }
    }
    return arr;
}//最好情况:O(n)  最坏情况O(n^2)  平均情况O(n^1.3)
function 选择排序(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;
}//最好情况:O(n^2)  最坏情况O(n^2)  平均情况O(n^2)

function 归并排序(){
    function mergeSort(arr){
        // 设置终止的条件，
        if (arr.length < 2) {
          return arr;
        }
        //设立中间值
        var middle = parseInt(arr.length / 2);
        //第1个和middle个之间为左子列
        var left = arr.slice(0, middle);
        //第middle+1到最后为右子列
        var right = arr.slice(middle);
        if(left=="undefined"&&right=="undefined"){
           return false;
        }
        return merge(mergeSort(left), mergeSort(right));
      }
      
      function merge(left, right){
        var result = [];
      
        while (left.length && right.length) {
          if(left[0] <= right[0]){
            //把left的左子树推出一个，然后push进result数组里
             result.push(left.shift());
          }else{
            //把right的右子树推出一个，然后push进result数组里
           result.push(right.shift());
          }
        }
        //经过上面一次循环，只能左子列或右子列一个不为空，或者都为空
        while (left.length){
          result.push(left.shift());
        } 
        while (right.length){
          result.push(right.shift());
        }
        return result;
      }
      // 测试数据
      var nums=[6,10,1,9,4,8,2,7,3,5]；
      mergeSort(nums);
}//时间复杂度O(nlogn的对数)