排序算法

数组排序问题:细研究这几种排序的算法,挺有意思

function swap(x,y,arr){
    var temp = arr[x]
    arr[x] = arr[y]
    arr[y] = temp
}

冒泡排序：比较相邻的两个项，如果第一个比第二大，则交换它们。元素项向上移动至正确的顺序。

冒泡排序升级版：如果从内循环减去外循环中已跑过的轮数,就可以避免循环中所有不必要的比较

本质上是：每循环一次内层循环，都会将当前最大的值放置arr.length-i的位置，可以看console.log(arr)的值

function bubbleSort(arr){
    for(var i = 0; i < arr.length; i++){
        for(var j = 0; j < arr.length-i; j++){
            if(arr[j] > arr[j+1]){
                swap(j,j+1,arr)
            }
        }
    }
    return arr
}   

选择排序：找到数据结构中最小值并将其放置第一位，接着找到第二小的值并将其放在第二位，以此类推。

个人理解：选择排序和冒泡排序是相反的两个操作，选择排序是每轮循环都将最小值放置i的位置，可以看console.log(arr)的值

function selectSort(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
            }
        }
        if(arr[i] > arr[minIndex]){
            swap(i,minIndex,arr)
        }
    }
    return arr
}  

插入排序：每次排一个数组项以此方式构建最后的排序数组。

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

归并排序

function mergeSort(arr){
    function merge(left,right){
        var leftLen = left&&left.length,rightLen = right&&right.length;
        var result = []
        var m = 0,n = 0;
        while(m < leftLen && n < rightLen){
            left[m] < right[n]?result.push(left[m++]):result.push(right[n++])
        }
        while(m < leftLen){
            result.push(left[m++])
        }
        while(n < rightLen){
            result.push(right[n++])
        }
        return result
    }
    var len = arr.length
    if(len == 1){
        return arr
    }
    var mid = Math.floor(len/2),left = arr.slice(0,mid),right = arr.slice(mid)
    return merge(mergeSort(left),mergeSort(right))
}

快速排序

function quickSort(arr){
    if(arr.length <= 1){
        return arr
    }
    var baseVal = arr.splice(0,1)[0],left = [],right = [];
    for(var i = 0;i < arr.length;i++){
        arr[i] < baseVal?left.push(arr[i]):right.push(arr[i])
    }
    return quickSort(left).concat([baseVal],quickSort(right))
}

计数排序升级版：使用min避免避免空间浪费

function countingSort(arr){
    let min = Math.min(...arr)
    let max = Math.max(...arr)
    let initArr = new Array(max-min+1).fill(0)
    let result = []
    for(let i = 0;i < arr.length;i++){
        let item = arr[i]
        initArr[item-min]++
    }
    for(let j = 0;j < initArr.length;j++){
        let jItem = initArr[j]
        while(jItem > 0){
            result.push(j+min)
            jItem--
        }
    }
    return result
}

基数排序:这个排序有点意思,根据数值的基数位的值分别排序最后得到的排序数组 暂未添加

function radixSort(sort){

 

}