排序算法总结

冒泡法：

思路：每次循环都两两比较，每循环一次都把最大的值放在后边。

function bubbleSort(arr) {
        var len = arr.length;
        for (var i = 0; i < len; i++) {
            for (var j = 0; j < len - 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 selectSort(arr) {
        var len = arr.length;
        var minIndex = 0;
        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;
                }
            }
            var temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
        return arr
    }

插入排序

思路：在一个数组中我们不知道哪个是最小值，那么就假定第一个就是最小值，然后取第二个值与第一个值比较产排序后的序列，然后再取第三个值与排序后的序列进行比较插入到对应的位置，依次类推。

 function insertSort(arr) {
        var len = arr.length;
        for (var i = 1; i < len; i++) {
            var key = arr[i];
            var j = i - 1;
            while (arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;

        }
        return arr;
    }

归并排序

思路：每次把数组分割成一半，再把两个排好序的数组合并成一个有序数组，然后每一层递归，当数组长度小于2的时候就返回数组。

function mergeSort(arr){
        var len=arr.length;
        if(len<2){
            return arr;
        }
        var mid=Math.floor(len/2)
        var left=arr.slice(0,mid)
        var right=arr.slice(mid)
        return merge(mergeSort(left),mergeSort(right))
       }
       function merge(left,right){
        var res=[];
        while(left.length && right.length){
            if(left[0]<=right[0]){
                res.push(left.shift())
            }else{
                res.push(right.shift())
            }
        }
        while(left.length){
            res.push(left.shift())
        }
        while(right.length){
            res.push(right.shift())
        }
        return res;
       }

快速排序

思路：每次选择一个基准值，建立两个数组，小雨这个基准值的就放left里，大于这个基准值的就放right里，然后再把left，基准值，right连接起来组成一个数组，然后再递归就可以了

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