JavaScript实现部分排序算法【冒泡，选择，插入，快排，希尔，归并】

实现了冒泡，选择，插入，快排，希尔，归并

冒泡排序

//外层遍历：len-1>=i>0;  i--
//内层遍历：0<=j<i;  j++
//定义一个flag做代码优化
function bubbleSort(arr){
    var len = arr.length;            
    var tmp;
    for(var i=len-1; i>0; i++){
        var flag = true;
        for(var j=0; j<i; j++){
            if(arr[j]>arr[j+1]){
                tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
                flag = false;
            }
        }
        if(flag){
            return arr;
        }
    }
}

选择排序

//外层排序：1<=i<len; i++;
//内层排序：i+1<=j<len; j++
//左侧默认有序，从右边选出一个最小值来与最左边的最大值进行交换


function selectSort(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;
            }
        }
        if(minIndex !== i){
            temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
    return arr;
}

插入排序

//外层循环：1<=i<len; i++;
//内层循环：记录arr[i],当左边默认排好序的数组中的数比arr[i]大时，将它们左移

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

快速排序

//注意：需要加上if(arr.length <=1) return arr;
//否则会导致栈溢出
function quickSort(arr){
    if(arr.length <= 1) return arr;
    var num = Math.floor(arr.length/2);
    var numValue = arr.splice(num,1);
    var left = [];
    var right = [];
    //此处判断条件为i<arr.length;不能是i<len;因为前面已经进行过splice操作，此时的len与arr.length并不相等
    for(var i=0; i<arr.length; i++){
        if(arr[i]<numValue){
            left.push(arr[i])
        }else{
            right.push(arr[i])
        }
    }
    return quickSort(left).concat(numValue,quickSort(right))
}

希尔排序

function shellSort(arr){
    // 1.获取数组的长度
    var length = arr.length

    // 2.根据长度计算增量
    var gap = Math.floor(length / 2)

    // 3.增量不断变量小, 大于0就继续排序
    while (gap > 0) {
        // 4.实现插入排序
        for (var i = gap; i < length; i++) {
            // 4.1.保存临时变量
            var j = i
            var temp = arr[i]

            // 4.2.插入排序的内层循环
            while (j-gap>=0 && arr[j - gap] > temp) {
                arr[j] = arr[j - gap]
                j -= gap
            }

            // 4.3.将选出的j位置设置为temp
            arr[j] = temp
        }
      
        // 5.重新计算新的间隔
        gap = Math.floor(gap / 2)
    }
    return arr;
}

归并排序

//归并排序
//分治法
//先将一个数组分为左右两个数组        
function mergeSort(arr){
    var len = arr.length;
    if(len<2) 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));
}

//将左右两个数组排序后以result返回
function merge(left,right){
    var result = [];

    while(left.length>0 && right.length>0){
        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());
    }
    return result;
}