一、 選擇排序

1. 概念理解:
   在一個長度為3的數組中，在第一趟遍歷3個數據，找出其中最小的數值與第一個元素交換；
   第二趟遍歷2個數據，找出其中最小的元素與第一個數交換(註意:這裏的第一個數是指遍歷的第一個數,實質上是數組的第二個數)
   而第三趟則是和自己比較,位置還是原來的位置

2. 復雜度:
   平均時間復雜度：O（n^2）

3. 例子:

//選擇排序
function selectionSortFn(arr){
    console.log(‘原數組:[‘+ arr + ‘]‘)
    
    for (var i = 0; i < arr.length; i++) {
        for (var j = i+1; j < arr.length; j++) {
            if (arr[i] > arr[j]) {
                var temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        console.log(arr);
    }
    return arr;
}

var initArr = [10, 4, 8, 3];
selectionSortFn(initArr);
 

我們看一下打印的結果:
[選擇排序]

原數組:[10,4,8,3]
[3, 10, 8, 4]
[3, 4, 10, 8]
[3, 4, 8, 10]
[3, 4, 8, 10]

結合概念就很好理解了。

二、 冒泡排序

1. 概念理解:
   依次比較相鄰的兩個數，將小數放在前面，大數放在後面。
   第一趟：首先比較第一個和第二個數，將小數放前，大數放後，然後比較第二個數和第三個數將小數放前，大數放後，如此繼續，直至比較最後兩個數，將小數放前，大數放後,至此第一趟結束。
   在第二趟：仍從第一對數開始比較 （因為可能由於第2個數和第3個數的交換，使得第1個數不再小於第2個 數），將小數放前中，大數放後，一直比較到倒數第二個數（倒數第一的位置上已經是最大的），第二趟 結束。在倒數第二的位置上得到一個新的最大數（其實在整個數列中是第二大的數）。
   如此下去，重復以上過程，直至最終完成排序。

2. 復雜度
   時間復雜度：O（n^2）

3. 例子

//冒泡排序
function bubbleSortFn(arr){
    console.log(‘原數組:[‘+arr + ‘]‘)
    
    for (var i = 0; i < arr.length-1; i++) {
        for (var j = 0; j < arr.length-1-i; j++) {
        //每次比較都會確定一個最小數，所以j < arr.length-1-i
            if (arr[j] > arr[j+1]) {
                var temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        console.log(arr)
    }
    return arr;
}

var initArr = [10, 4, 8, 3];
bubbleSortFn(initArr);
 

我們看一下打印的結果:

原數組:[10,4,8,3]
[4, 8, 3, 10]
[4, 3, 8, 10]
[3, 4, 8, 10]

三、 快速排序

1. 概念理解:
   • 在帶排序的元素中任取一個元素作為基準（通常選第一個），稱為基準元素；
   • b將帶排序的元素進行分區，比基準元素大的元素放在他的右邊，比他小的放在左邊；
   • c對左右兩個分區重復以上步驟(遞歸)直達所有元素有序；
2. 復雜度
   時間復雜的：O（nlogn）
3. 例子

//快速排序
function quickSortFn(arr){
    console.log(‘原數組:[‘+arr + ‘]‘)
    // 如果數組長度<=1 ，則直接返回
    if (arr.length <= 1) return arr;
    //
    var bisectionIndex = Math.floor(arr.length/2);
    // 找基準，把基準從原數組中刪除
    var bisection = arr.splice(bisection,1)[0];
    // console.log(bisection);

    // 定義作用數組
    var left = [];
    var right = [];

    // 比基準小的放left ，比基準大的放right
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] <= bisection) {
            left.push(arr[i]);
        }else{
            right.push(arr[i]);
        }
        console.log(arr);
    }
    //遞歸
    return quickSortFn(left).concat([bisection],quickSortFn(right));
}

var initArr = [10, 4, 8, 3];
quickSortFn(initArr);

我們看一下打印結果:

[4, 8, 3]
[4, 8, 3]
[4, 8, 3]
[8, 3]
[8, 3]

四、插入排序

1. 概念理解:
   檢查第i個數字，如果在它的左邊的數字比它大，進行交換，這個動作一直繼續下去，直到這個數字的左邊數字比它還要小，就可以停止了。

2. 復雜度
   時間復雜度：O（n^2）

3. 例子

//插入排序
function insertSortFn(arr){
    console.log(‘原數組:[‘+arr + ‘]‘)
    for (var i = 1; i < arr.length; i++) {
        var temp = arr[i];
        for (var j = i-1; j >=0 && temp < arr[j]; j--) {
            arr[j+1] = arr[j];
            arr[j] = temp;
        }
        console.log(arr)
    }
    return arr;
}

var initArr = [10, 4, 8, 3];
insertSortFn(initArr);

我們看一下打印結果:

原數組:[10,4,8,3]
[4, 10, 8, 3]
[4, 8, 10, 3]
[3, 4, 8, 10]

四、總結

1. 冒泡排序是排序裏面最簡單的了，但性能也最差，數量小的時候還可以，數量多，是非常慢的。
2. 冒泡、選擇、插入三個排序復雜度都是一樣的(慢)
3. 快速排序效率最高。平均時間復雜度是 O(Nlog2N)，最差也是O(N*N)，空間復雜度O(Nlog2N)

總結4種常用排序(快排、選擇排序、冒泡排序、插入排序)