javascript之排序算法

排序算法

记录一些常见的简单的算法

1. 冒泡排序，最简单的算法，从运行时间角度看，性能最差一个,比较相邻项，交换位置O(n2)

function swap(array, i, j) {
      [array[j], array[i]] = [array[i], array[j]]
 }

 const Compare = {
       LESS_THAN: -1,
       BIGGER_THAN: 1,
       EQUAL_THAN: 0
 }
function defaultCompareFn(a, b) {
       if (a === b) {
            return Compare.EQUAL_THAN;
       }
    return a < b ? Compare.LESS_THAN : Compare.BIGGER_THAN;
}
function modifiedBuddleSort(array,compareFn = defaultCompareFn){
    const {length} =array;
    for(let i=0;i<length;i++){
        for(let j =0;j<length-1-i;j++){
            if(compareFn(array[j],array[j+1])===Compare.BIGGER_THAN){
                swap(array,j,j+1)
            }
        }
    }
    return array;
}

2.选择排序,原址排序，找到最小值放第一位，第二小放第二位，以此类推O(n2)

function selectionSort(array,compareFn = defaultCompareFn){
    const {length} =array;
    let indexMin;
    for(let i=0;i<length-1;i++){
        indexMin =i;
        for(let j=i;j<length;j++){
            if(compareFn(array[indexMin],array[j])===Compare.BIGGER_THAN){
                indexMin = j;
            }
        }
        if(i!==indexMin){
            swap(array,i,indexMin);
        }
    }
    return array;
}

3.插入排序,每次排一个数组项,以此构建最后排序数组，假定第一项已经排序过，接着和第二项进行比较-，看第二项是否要插入第一项以前，接着和第三项比较，看须要查到哪，以此类推/排序小型数组，这个比选择和冒泡性能好。

function insertionSort(array, compareFn = defaultCompareFn){
    const {length}=array;
    let temp;
    for(let i=1;i<length;i++){
        let j =i;
        temp = array[i];
        while(j>0&&compareFn(array[j-1],temp)=== Compare.BIGGER_THAN){
            array[j] = array[j-1];
            j--;
        }
        array[j] = temp;
    }
    return array;
}

4.计数排序,(整数排序算法),一个数组计算，数字出现过的次数

function countingSort(array) {

     if (array.length < 2) {

        return array;

     }

     const maxValue = findMaxValue(array);

     const counts = new Array(maxValue + 1);

     array.forEach(element => {

         console.log(element)

         if (!counts[element]) {

         counts[element] = 0;

         }

         counts[element]++;

     });

    console.log(counts)

    let sortedIndex = 0;

     counts.forEach((count, i) => {

         while (count > 0) {

             array[sortedIndex++] = i;

             count--;

         }

     })

    return array;

 }

 function findMaxValue(array) {

     let max = array[0];

     for (let i = 1; i < array.length; i++) {

         if (max < array[i]) {

            max = array[i];

         }

     }
     return max;
 }

5.归并排序加去重,O(nlog(n))，分而治之算法，将原始数组切分红较小的数组，直到每一个小数组只有一个位置，而后再将小的合并成较大数组，直到最后一个排序完毕的大数组。
分治法，递归实现。

function mergeSort(array,compareFn = defaultCompareFn){
    if(array.length>1){
        const {length} = array;
        const middle = Math.floor(length/2);
        const left = mergeSort(array.slice(0,middle),compareFn);//划分
        const right = mergeSort(array.slice(middle),compareFn);//划分
        array = merge(left,right,compareFn)//合并 治
    }
    return array;
}

function merge(left,right,compareFn){
    const res = [];
    while(left.length>0&&right.length>0){
        if(compareFn(left[0],right[0])===Compare.LESS_THAN){
            res.push(left.shift())
        }else if(compareFn(left[0], right[0]) === Compare.EQUAL_THAN){
            left.shift();
        }else{
            res.push(right.shift())
        }
    }
    return res.concat(left).concat(right);
}

未完待续