JavaScript基礎 - 數組排序的6種方法

1. sort()

sort() 按照 ASCII 字符排序，默認升序。

普通數組

// 數字
var sum = 0;
var numbers = [4, 2, 5, 1, 3];
numbers.sort(function(a, b) {
    sum++;
    return a - b;
});

console.log(numbers); // 1 2 3 4 5
console.log(sum); // 7

// 字符串
const months = ['March', 'Jan', 'Feb', 'Dec'];
months.sort();

console.log(months);  // ['Dec', 'Feb', 'Jan', 'March']

數組對象

var student = [
    {'name': 'jack', 'age': 18},
    {'name': 'apple', 'age': 16},
    {'name': 'tony', 'age': 30},
    {'name': 'marry', 'age': 8},
]
// 按年齡
student.sort(function (a, b) {
    return (a.age - b.age)
});

// 按姓名
student.sort(function (a, b) {
  var nameA = a.name.toUpperCase();
  var nameB = b.name.toUpperCase();
  if (nameA < nameB) {
    return -1;
  }
  if (nameA > nameB) {
    return 1;
  }
});

2. 冒泡排序

相鄰兩個數逐個比較，若是前一個數比後一個數小則交換位置。

重點：交換過程須要變量存儲較小值/較大值

var numbers = [4, 2, 5, 1, 3];

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

console.log(bubbleSort(numbers));
console.log(sum) // 20

3. 快速排序

冒泡排序的改進算法。經過屢次的比較和交換來實現排序。

重點：需設定分界值，根據分界值將數組分爲左右兩部分。而後在左右兩邊不斷重複取分界值和分左右部分的操做。

var numbers = [4, 2, 5, 1, 3];

var sum = 0;
function quickSort (arr) {
    if (arr.length <= 1) {
        return arr;
    }
    var medianIndex = Math.floor(arr.length / 2); // 分解值索引
    var medianValue = arr.splice(medianIndex, 1); // 分界值
    var left = [];
    var right = [];
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] < medianValue) {
            left.push(arr[i])
        } else {
            right.push(arr[i])
        }
        sum++;
    }
    console.log(medianIndex, medianValue, left, right)
    return quickSort(left).concat(medianValue,quickSort(right));
};

console.log(quickSort(numbers));
console.log(sum) // 10

4. 插入排序

假設前面 n-1 的元素已經排好序，將第n個元素插入到前面已經排好的序列中。

重點：需定義有序序列中最後一個位置，從最後一位開始不斷和序列前元素進行比較，直到找到插入位置。

var numbers = [4, 2, 5, 1, 3];

var sum = 0;
function insertSort(arr) {
    // 假設第一個元素已經排好序
    for (let i = 1; i < arr.length; i++) {
        if (arr[i] < arr[i - 1]) {
            // 取出無序序列中須要插入的第i個元素
            var temp = arr[i];
            // 定義有序中的最後一個位置
            var j = i - 1;
            arr[i] = arr[j];
            // 根據序列最後一位，不斷循環比較，找到插入的位置
            while(j >= 0 && temp < arr[j]){
                arr[ j+1 ] = arr[j];
                j--;
                sum++;
            };
            //插入
            arr[ j+1 ] = temp;
        }
    }
}

console.log(insertSort(numbers));
console.log(sum) // 6

5. 希爾排序

希爾排序是把記錄按下標的必定增量分組，對每組使用直接插入排序算法排序。

希爾排序是插入排序算法的一種更高效的改進版本。

var numbers = [4, 2, 5, 1, 3];
var sum = 0;

function shellSort(arr) {
    var len = arr.length;
    // 定義間隔區間
    var fraction = Math.floor(len / 2);
    // fraction = Math.floor(fraction / 2) => 循環中不斷切割區間
    for (fraction; fraction > 0; fraction = Math.floor(fraction / 2)) {
        // 以間隔值開始遍歷
        for (var i = fraction; i < len; i++) {
            // 若是前面一個大於後面一個
            for (var j = i - fraction; j >= 0 && arr[j] > arr[fraction + j]; j -= fraction) {
                var temp = arr[j];
                arr[j] = arr[fraction + j]; // 後移
                arr[fraction + j] = temp; // 填補
                sum++;
            }
        }
    }
}

console.log(shellSort(numbers));
console.log(sum) // 6

6. 選擇排序

從待排序的數據元素中選出最小/最大的一個元素，存放在序列的起始位置，而後再從剩餘的未排序元素中尋找到最小/最大元素，而後放到已排序的序列的末尾。以此類推，直到所有待排序的數據元素的個數爲零。

var numbers = [4, 2, 5, 1, 3];

var sum = 0;
function selectionSort(arr) {
    if (arr == null || arr.length < 2) {
        return arr;
    }
    for (var i = 0; i < (arr.length - 1); i++) {
        let minIndex = i;
        for (let j = i + 1; j < arr.length; j++) {
            minIndex = arr[j] < arr[minIndex] ? j : minIndex;
            sum++;
        }
        let temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
    return arr;
}


console.log(selectionSort(numbers));
console.log(sum) // 10

7. 比較

以同一個數組[4, 2, 5, 1, 3]不一樣的方法比較計算次數。

方法	計算次數	穩定性
sort()	7
冒泡排序	20	穩定
快速排序	10	不穩定
插入排序	6	穩定
希爾排序	6	不穩定
選擇排序	10	不穩定