排序方法

冒泡排序

比较两个相邻的元素，将值大的元素交换到右边，需要n-1趟排序，每趟需要n-i次，这种方式通过多次迭代数组来完成操作，不管是平均还是最坏的情况，都是具有二次时间复杂度。尽管这个方式简单，但是在实际应用中，大多数情况下不切实际的：时间复杂度过高。

function bubbleSort(arr) {
    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]){
                let tem = arr[j+1];
                arr[j+1] = arr[j];
                arr[j] = tem;
            }
        }
    }
return arr;
}

选择排序

选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。重复第二步，直到所有元素均排序完毕。

function selectionSort(arr) {
    for(var i=0;i<arr.length-1;i++){
        var minindex=i;
        for(var j=i+1;j<arr.length;j++){
            if(arr[j]<arr[minindex]){
                minindex = j;
            }
        }
        var temp = arr[i];
        arr[i] = arr[minindex];
        arr[minindex] = temp;
    }
  return arr;
}

插入排序

将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

function insertionSort(arr) {
    for(var i=1;i<arr.length;i++){
        var preindex = i-1;
        var current = arr[i];
        while(preindex>=0 && current<arr[preindex]){
            arr[preindex+1] = arr[preindex];
            preindex--;
        }
        arr[preindex+1] = current;
    }
  return arr;
}

归并排序

递归的将输入数组拆分成两个子数组，直到所有的子数组都只包含一个元素。将每一个排序后的子数组合并到一个数组里面，最后返回一个排序的数组。合并的时候，从长度为1的数组向上合并，合并的时候数组在排序，而快速排序是拆分的时候在排序

function mergeSort(arr){
    var len = arr.length;
    if(len<2){ //最终要把arr变成长度为1或0的数列
      return arr;
    }
    var middle = Math.floor(len/2);
    var left = arr.slice(0,middle);
    var right = arr.slice(middle);
    return merge(mergeSort(left),mergeSort(right));
}

function merge(left,right){
    var result = [];
    while(left.length && right.length){
      if(left[0]<=right[0]){
        result.push(left.shift());
      }
      else{
        result.push(right.shift());
      }
    }

    while(left.length){
      result.push(left.shift());
    }
    while(right.length){
      result.push(right.shift());
    }
}

快速排序

选择一个基准，比基准大的放在左边数组，大的放在右边数组，不断递归至数组只有一个元素。

function quickSort(arr){
    var len = arr.length;
    if(len<2){
        return arr;
    }
    var pivotIndex = Math.floor(len/2);
    var pivot = arr[pivotIndex];
    var left=[],right=[];
    for(var i=0;i<len;i++){
        if(i===pivotIndex){
            continue;
        }
        if(arr[i]<pivot){
            left.push(arr[i]);
        }
        else{
            right.push(arr[i]);
        }
    }
    return quickSort(left).concat([pivot],quickSort(right));
}

function swap(array,a,b){
    [array[a],array[b]] = [array[b],array[a]];
}
//冒泡排序
function bubbleSort(array){
    let len = array.length;
    for (let i = 0; i < len; i++){ 
        for(let i=0; i < len-1-i; i++){
        if(array[i]>array[i+1]){
            swap(array,i,i+1);
        }
    }
    }
    return array;
}
//选择排序
function selectSort(array){
    let len = array.length;
    let indexmin;
    for(let i=0;i<len-1;i++){
        indexmin = i;
        for(let j=i;j<len;j++){
            if(array[i]>array[j]){
                indexmin = j;
            }
        }
        if(i!=indexmin){
            swap(array,i,indexmin);
        }
    }
    return array;
}
//插入排序
function insertSort(array){
    let len = array.length;
    let tmp;
    for(let i=1;i<len;i++){
        tmp = array[i];
        let j = i;
        while(j>0 && array[j-1]>tmp){
            array[j] = array[j-1];
            j--;
        }
        array[j]= tmp;
    }
    return array;
}
//归并排序
function mergeSort(list) {
    var length = list.length;
    if(length==1){ //结束条件
        return list;
        }
    var mid = Math.floor(length/2);
    var left = list.slice(0,mid);
    console.log(left);
    var right = list.slice(mid,length);
    return merge(mergeSort(left),mergeSort(right));//递归
};

function merge(left,right) {
    var result = [];
    var nl = 0;
    var nr =0;
    while(nl<left.length && nr<right.length){
        if(left[nl]<right[nr]){//按从小到大的顺序排列新的组合数组
            result.push(left[nl++]);//扔进去之后迭代
        }else{
            result.push(right[nr++]);
        }

    }
    while(nl<left.length){//剩下的一股脑儿扔进去。
        result.push(left[nl++]);

    }
    while(nr<right.length){
        result.push(right[nr++]);

    }

    return result;
}
//快速排序
function quick(array){
    if(array.length<=1){
        return array;
    }
    let mid = Math.floor(array.length/2);
    let midValue = array.splice(mid,1)[0];
    let arrleft = [],
        arrright = [];
    for(let i=0;i<array.length;i++){
        let item = array[i];
        item<midValue?arrleft.push(item):arrright.push(item);

    }
    return quick(arrleft).concat(midValue,quick(arrright));
}

var arr =[5,4,3,2];
var s = quick(arr);
console.log(s);