前端需要知道的排序算法

今天好好的學習了下關於排序的算法，以下是一些總結，也算是一種鞏固。

首先排序算法沒有什么優劣之分，在不同的場景中，不同的排序算法執行效率不同。

1.選擇排序(selection sort):

一次排序，可以將某個區間的最小值排列到該區域的第一位

例如：數組[5, 1, 3, 2, 4, 6]

步驟一：選擇該數組的最小值，一般設置為第一個值5，

步驟二：將該值與下面的值比較，如果下面的值小，就互換值，否則不變，

步驟三：循環下一個區域。

　　例如：[5, 1, 3, 2, 4, 6] 中默認最小值為5，然后跟后續區域最小值互換即1。[1, 5, 3, 2, 4, 6]

　　　　　[1, 5, 3, 2, 4, 6]找出下一個區間[5, 3, 2, 4, 6]中默認最小值5，然后跟后續區域最小值互換即2，[2, 3, 5, 4, 6]

　　　　　[2, 3, 5, 4, 6]找出下一個區間[3, 5, 4, 6]中默認最小值3，然后跟后續區域最小值互換即4，沒他小，不換 [3, 5, 4, 6]后續以此類推

//顛倒數組值
function swap(arr, i1, i2) {
    var temp = arr[i1];
    arr[i1] = arr[i2];
    arr[i2] = temp;
}
/**
 * 選擇排序
 * @param {*} arr 
 */
function selectionSort(arr) {
    for (var i = 0; i < arr.length - 1; i++) {
        //先記錄其最小值，如果后面有比他還小的就換位置
        var min = arr[i];
        var index = i;
        for (var j = i + 1; j < arr.length - 1; j++) {
            if (arr[j] < min) {
                min = arr[j];
                index = j;
            }
        }
        swap(arr, i, index);
    }
}

　var arr = [5, 1, 3, 2, 4, 6];

  selectionSort(arr);

  console.log(arr)

2.冒泡排序(bubble sort)：

一次冒泡排序，可以將某個區域序列的最大值排序到該區域的最后一位，具體的方式是：

1. 將第1位和第2位比較，如果前者比后者大則交換
2. 將第2位和第3位比較，如果前者比后者大則交換
3. 依次類推，直到比較到該區域的最后兩位
4. 重復上述過程，直到序列排序完成

例如：[5, 1, 3, 2, 4, 6] 

　　第一次：[1, 5, 3, 2, 4, 6]

　　第二次：[1, 3, 5, 2, 4, 6] 

　　第三次：[1, 3, 2, 5, 4, 6] 

　　第四次：[1, 3, 2, 4, 5, 6] 以此類推

/**
 * 冒泡排序
 * @param {*} arr 
 */
function bubbleSort(arr) {
    for (var i = 0; i < arr.length - 1; i++) { //循環了幾次
        for (var j = 0; j < arr.length - 1 - i; j++) {
            //需要經過arr.length-1次的冒泡
            //i:0   循環：0~arr.length-1-i
            //i:1   循環：0~arr.length-1-i
            //i:2   循環: 0~arr.length-1-i
            if (arr[j] > arr[j + 1]) {
                swap(arr, j, j + 1);
            }
        }
    }
}
var arr = [5, 1, 3, 2, 4, 6];
bubbleSort(arr);
console.log(arr)

3.插入排序(insertion sort):

將序列分為兩個部分，一部分是有序的，一部分是無序的，現在要做的是，就是不斷的從無序的部分取出數據，加入到有序的部分，直到整個排序完成

原理：序列[5, 7, 2, 3, 6]

1. 分為有序的序列和無序的序列 (5) (7 2 3 6)
2. 不斷的擴充有序序列 (5 7) (2 3 6)
3. 不斷的擴充有序序列 (2 5 7) (3 6)
4. 不斷的擴充有序序列 (2 3 5 7) (6)
5. 不斷的擴充有序序列 (2 3 5 6 7)
6. 排序完成

程序寫法：

[5, 1, 3, 2, 4, 6]，假設有序序列為（5，1,3），先保存其以后的第一個值arr[i]為temp=2,然后將temp和有序列表最后一位的前一個的值比較，
此時其最后一位的前一個為1，比temp小，所以temp就放置在最后一位上，其原來的值放在有序列表最后，就會變成(5,1,2,3),循環后即可

/**
 * 插入排序
 * @param {*} arr 
 */
function insertionSort(arr) {
    for (var i = 1; i < arr.length; i++) {
        if (arr[i] < arr[i - 1]) { //如果前一位大於該位，
            //將第i位的值加入到前面有序隊列的正確位置
            var temp = arr[i];
            for (var j = i; j >= 0; j--) {
                if (j > 0 && arr[j - 1] > temp) {
                    arr[j] = arr[j - 1];//如果有序列表的最后一位的前一位大於temp，就將有序列表的最后一位設為其前一位。
                }
                else { //如果有序列表的最后一位的前一位小於temp，那就將最后一位設為temp。
                    arr[j] = temp;
                    break;
                }
            }
        }
    }
}
var arr = [5, 3, 1, 6, 7, 4];
insertionSort(arr)
console.log(arr);

4.快速排序(quick sort):

選擇一個數（比如序列的最后一位）作為基准數，將整個序列排序成兩部分，一部分比該數小，另一部分比該數大，基准數在中間，然后對剩余的序列做同樣的事情，直到排序完成

例如：序列[5, 7, 2, 3, 6, 4]

1. 選擇4作為基准數，排序成為：(3, 2) 4 (7, 6, 5)
2. 對於3,2， 繼續使用該方式排序，得到： (2, 3) 4 (7,6,5)
3. 對於7,6,5，繼續使用該方式排序，得到： (2, 3) 4 (5,6,7)
4. 排序完成

function quickSort(arr){
    /**
     * 
     * @param {*} arr 
     * @param {*} start 開始下標 
     * @param {*} end  結束下標
     */
    function _quickSort(arr,start,end) {
        if (start >= end || start > arr.length - 1) return;
        var high = end,low = start;//設置高位和地位
        var key = arr[high]; //設置基准值是最后一位
        while (low < high) {
            while (low < high && arr[low] <= key) low ++ ; //如果低位的值小於基准值，低位向高位靠攏
            arr[high] = arr[low]; //如果發現低位值大於基准值，將該位的值放在高位，且低位不再向高位靠攏
            while (low < high && arr[high] >= key) high--; //低位不動，如果高位大於基准值，高位向低位靠攏 ，
            arr[low] = arr[high];//靠攏過程中，如果高位小於基准值，將值放到靠攏的低位。
        }
        arr[low] = key;//高位等於低位時，將基准值放入。
        _quickSort(arr,start,low - 1);//循環快速排序基准值左邊的數組
        _quickSort(arr,high+1,end);//快速排序基准值右邊的數組
    }   
    _quickSort(arr,0,arr.length-1);
}
var arr = [5, 1, 3, 2, 4, 6];
quickSort(arr);
console.log(arr)