js 排序算法

1、比較算法的複雜性

• 算法的複雜性體如今運行該算法時的計算機所需資源的多少上，計算機資源最重要的是時間和空間（即寄存器）資源，所以複雜度分爲時間和空間複雜度

1.一、時間複雜度

• 算法的時間複雜度是一個函數，它定性描述了該算法的運行時間。

1.二、空間複雜度

• 空間複雜度是指執行這個算法所須要的內存空間。

2、常見的排序算法

2.一、冒泡排序

• 時間複雜度 O(n^2)
• 空間複雜度 O(1)

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+1]; //元素交換
                arr[j+1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
}
複製代碼

2.二、 選擇排序

• 時間複雜度 O(n^2)
• 空間複雜度 O(1)

function selectionSort(arr) {
    var len = arr.length;
    var minIndex, temp;
    console.time('選擇排序耗時');
    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; //將最小數的索引保存
            }
        }
        temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
    console.timeEnd('選擇排序耗時');
    return arr;
}
複製代碼

2.三、插入排序

• 時間複雜度 O(n^2)
• 空間複雜度 O(1)

function insertionSort(array) {
    console.time('插入排序耗時：');
    for (var i = 1; i < array.length; i++) {
        var key = array[i];
        var j = i - 1;
        while ( array[j] > key) {
            array[j + 1] = array[j];
            j--;
        }
        array[j + 1] = key;
    }
    console.timeEnd('插入排序耗時：');
    return array;
}
複製代碼

2.四、 希爾排序

• 時間複雜度 O(nlogn)
• 空間複雜度 O(1)

function shellSort(arr) {
    var len = arr.length,
    temp,
    gap = 1;
    console.time('希爾排序耗時:');
    while(gap < len/5) { //動態定義間隔序列
        gap =gap*5+1;
    }
    for (gap; gap > 0; gap = Math.floor(gap/5)) {
        for (var i = gap; i < len; i++) {
            temp = arr[i];
            for (var j = i-gap; j >= 0 && arr[j] > temp; j-=gap) {
                arr[j+gap] = arr[j];
            }
            arr[j+gap] = temp;
        }
    }
    console.timeEnd('希爾排序耗時:');
    return arr;
}
複製代碼

2.五、 快速排序

• 時間複雜度 O(nlogn)
• 空間複雜度 O(logn)

function quickSort(array, left, right) {
    console.time('1.快速排序耗時');
    if (left < right) {
        var x = array[right], i = left - 1, temp;
        for (var j = left; j <= right; j++) {
            if (array[j] <= x) {
                i++;
                temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
        console.log(array) ;
        console.log(left,i) ;
        quickSort(array, left, i - 1);
        console.log(array)
        console.log(i,right)
        quickSort(array, i + 1, right);
    }
    console.timeEnd('1.快速排序耗時');
    console.log(array)
    return array;
}
複製代碼

2.六、 堆排序

• 時間複雜度 O(nlogn)
• 空間複雜度 O(1)

function heapSort(array) {
    console.time('堆排序耗時');
    //建堆
    var heapSize = array.length, temp;
    for (var i = Math.floor(heapSize / 2) - 1; i >= 0; i--) {  
        heapify(array, i, heapSize);
    }
    //堆排序
    for (var j = heapSize - 1; j >= 1; j--) {
        temp = array[0];
        array[0] = array[j];
        array[j] = temp;
        console.log(array)
        heapify(array, 0, --heapSize);
    }
    console.timeEnd('堆排序耗時');
    return array;
}

function heapify(arr, x, len) {
    var l = 2 * x + 1, r = 2 * x + 2, largest = x, temp;
    if (l < len && arr[l] > arr[largest]) {
        largest = l;
    }
    if (r < len && arr[r] > arr[largest]) {
        largest = r;
    }
    if (largest != x) {
        temp = arr[x];
        arr[x] = arr[largest];
        arr[largest] = temp;
        console.log(arr)
        heapify(arr, largest, len);
    }
}
複製代碼