1.冒泡排序

平均時間復雜度O(N²) 最好情況O(N)最壞情況O(N²) 空間復雜度O(1)

function bubbleSort(arr){
    if(arr.length <= 1)
        return arr;
    var flag = 1;             // 標識是否進行交換
    for(var i=0; i < arr.length; i++){
        if(i !=0 && flag) break;
        for(var j=0; j < arr.length-i-1; j++){
            
 
if(arr[j] > arr[j+1]){
                if(flag == 1) flag = 0;
                var temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }    
    }
    return arr;
}
var a = [2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50];
console.log(bubbleSort(a));
 

升級版冒泡排序

function bubbleSort2(arr) {
　　var low = 0;
　　var high= arr.length-1; //設置變量的初始值
　　var tmp,j;
　　console.time(‘2.改進後冒泡排序耗時‘);
　　while (low < high) {
　　　　for (j= low; j< high; ++j) {         //正向冒泡,找到最大者
　　　　　　if (arr[j]> arr[j+1]) {
　　　　　　　　tmp = arr[j]; arr[j]=arr[j+1];arr[j+1]=tmp;
　　　　　　}
　　　　}
　　　　
 
--high;  //修改high值, 前移一位
　　　　for (j=high; j>low; --j) {          //反向冒泡,找到最小者
　　　　　　if (arr[j]<arr[j-1]) {
　　　　　　　　tmp = arr[j]; arr[j]=arr[j-1];arr[j-1]=tmp;
　　　　　　}
　　　　}　
　　　　++low;  //修改low值,後移一位
　　}
　　console.timeEnd(‘2.改進後冒泡排序耗時‘);
　　return arr;
}
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
console.log(bubbleSort2(arr));

2.選擇排序

平均時間復雜度O(N²) 最好情況O(N²)最壞情況O(N²) 空間復雜度O(1) 適合小數據（1000以內）排序

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;
}
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
console.log(selectionSort(arr));

3. 插入排序

平均時間復雜度O(N²) 最好情況O(N)最壞情況O(N²) 空間復雜度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;
}
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
console.log(insertionSort(arr));

升級版（通過二分法查找左邊有序數組中待差數字的插入位置）

function binaryInsertionSort(array) {
　　console.time(‘二分插入排序耗時：‘);
　　for (var i = 1; i < array.length; i++) {
　　　　var key = array[i], left = 0, right = i - 1;
　　　　while (left <= right) {
　　　　　　var middle = parseInt((left + right) / 2);
　　　　　　if (key < array[middle]) {
　　　　　　　　right = middle - 1;
　　　　　　} else {
　　　　　　　　left = middle + 1;
　　　　　　}
　　　　}
　　　　for (var j = i - 1; j >= left; j--) {
　　　　　　array[j + 1] = array[j];
　　　　}
　　　　array[left] = key;
　　}
　　console.timeEnd(‘二分插入排序耗時：‘);
　　return array;
}
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
console.log(binaryInsertionSort(arr));

4. 快速排序

平均時間復雜度O(NlogN) 最好情況O(NlogN)最壞情況O(N²) 空間復雜度O(logN)

function quickSort(arr){
    if(arr.length <= 1) return arr;
    var pivotIndex = Math.floor(arr.length/2);
    var pivot = arr.splice(pivotIndex,1)[0];
    var left = [];
    var right = [];
    for(var i = 0; i < arr.length; i++){
        if(arr[i] < pivot){
            left.push(arr[i]);
        }else{
            right.push(arr[i]);
        }
    }
    return quickSort(left).concat([pivot],quickSort(right));
}
var arr=[2,3,1];
console.log(quickSort(arr));

js 排序算法總結