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);
}

未完待續