簡單說一說排序算法

作爲一名合格的程序員，還是要懂一些排序算法。

學習這個話題，通常都會先學冒泡排序，因爲它在所有的排序算法中是最簡單也是最**的。當然，簡單是不會有好結果的。它的性能也是最差的。

冒泡排序通過比較任何兩個相鄰的項，如果第一個比第二個打，則交換它們。元素項向上移動至正確的順序，就好像氣泡從水中往上冒一樣。冒泡因此得名。

具體實現代碼：

function bubbleSort(array){   
    var length = array.length;
    for(var i = 0 ; i < length ; i++){
        for(var j = 0 ; j < length - 1 ; j++){  //for(var j = 0 ; i < length - 1 - j ; j++)
            if(array[j] > array[j+1]){
                var temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
    }
}

上面代碼註釋部分是對冒泡算法的優化：通過從內循環中減去外循環中一跑過的輪數，避免內循環中所有不必要的比較。

第二種算法是選擇排序，選擇排序算法是一種原址比較排序算法。含義就是找到數據結構中的最小值並將其放置在第一位，接着找到第二小的值並將其放在第二位，以此類推。

實現代碼：

function selectionSort (array){
        var length = array.length,
            indexMin;
        for(var i = 0 ; i < length - 1; i++){
            indexMin = i;
            for(var j = i ; i < length ; j++){
                if(array[indexMin] > array[j]){
                    indexMin = j;
                }
            }
            if(i !== indexMin){
                var temp = array[i];
                array[i] = array[indexMin];
                array[indexMin] = temp;
            }
        }
    }

第三種排序算法是插入排序，插入排序比較好理解，現實生活中比較明顯的例子就是插牌。你鬥地主的時候，一手牌拿着，然後從第二張開始排列，跟前面的序列進行對比。如果比前面的小則插到前面。
實現代碼：

function insertionSort (array){
        var length = array.length,
            j , temp;
        for(var i = 1; i < length ; i++){
            j = i;
            temp = array[i];
            while(j > 0 && array[j-1] > temp){
                array[i] = array[j-1];
                j--;
            }
            array[j] = temp;
        }
    }

排序小型數組時，此算法比前面兩個性能要好。

第四種排序算法是歸併排序，這也是第一個可以被實際使用的排序算法。歸併排序是一種分治算法，思路是將原始數組切分成比較小的數組，直到每個小數組只有一個位置，接着將小數組歸併成較大的數組，直到最後只有一個排序完畢的大數組。歸併排序應用的是遞歸的方式。

    function mergeSort (array){
        array = mergeSortRec(array);
    }
    var mergeSortRec = function(array){
        var length = array.length;
        if(length === 1){
            return array;
        }
        var mid = Math.floor(length / 2),
            left = array.slice(0 , mid),
            right = array.slice(mid , length);

        return merge(mergeSortRec(left) , mergeSortRec(right));
    }
    var merge = function(left , right){
        var result = [],
            il = 0,
            ir = 0;
        while(il < left.length && ir < right.length){
            if(left[il] < right[ir] && ir < right.length){
                if(left[i] < right[ir]){
                    result.push(left[il++]);
                }else{
                    result.push(right[ir++]);
                }
            }
        }
        while(il < left.length){
            result.push(left[il++]);
        }
        while(ir < right.length){
            result.push(right[ir++]);
        }
        return result;
    }

可以看到，算法首先將原始數組分割直至只有一個元素的子數組，然後開始歸併。

第五種排序算法是快速排序，也是最常用的排序算法了。同樣也是用了分治算法。

“快速排序”的思想很簡單，整個排序過程只需要三步：
　　（1）在數據集之中，選擇一個元素作爲”基準”（pivot）。
　　（2）所有小於”基準”的元素，都移到”基準”的左邊；所有大於”基準”的元素，都移到”基準”的右邊。
　　（3）對”基準”左邊和右邊的兩個子集，不斷重複第一步和第二步，直到所有子集只剩下一個元素爲止。
　　

       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));
        }

封裝後的源代碼

所有的排序算法就總結到這裏，有想法的小夥伴歡迎評論區留言！