javascript-幾個基礎的排序算法

對這幾個基礎排序算法進行梳理，便於之後查看。

/**
*
* 冒泡排序 
* 從末尾開始相鄰兩數相互比較大小,知足條件就交換位置。循環每進行一次，便可肯定第i位數的值。
*冒泡排序的時間複雜度爲O(n^2)。
*
*/
function bubbleSort(arr){
    if(arr == null || arr.length == 0) return;
    for(var i =0 ; i < arr.length-1 ;i++){      //比較n-1次便可
        for(var j = arr.length-1 ; j>i ;j--){
            if(arr[j] < arr[j-1]){

                var temp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = temp;
            }
        }
    }
    console.log(arr);
}



/** 
*
*選擇排序
*第i次循環，將arr[i]與後面的數比較，用它後面最小的數和它交換。
*選擇排序的時間複雜度爲O(n^2)
*/
function selectSort(arr){
    if(arr == null || arr.length == 0) return;
    for(var i = 0 ; i < arr.length-1 ;i++){
        var minIndex = i;
        for(var j = i + 1; j < arr.length ; j++){
            if(arr[minIndex] > arr[j]){
                minIndex = j;
            }            
        }
        if(minIndex !== i){
            var temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
            
        }
    }
    console.log(arr);
}

/**
*
*插入排序
*以第一個數爲參照，將第i個數拿出，對第i個數前面的數整理好順序後，將arr[i]插入正確位置。
*簡單插入排序的時間複雜度也是O(n^2)。
*/

function insterSort(arr){
    if(arr == null || arr.length == 0) return;
    for(var i = 1; i < arr.length ; i++){
        var j = i;
        var target = arr[i];  //插入值
        while(j > 0 && target < arr[j-1] ){
              arr[j] = arr[j-1];
                j --;
        }
         arr[j] = target;
    }
    console.log(arr);
}
/*
var a = [15,8,14,2,6];
insterSort(a);
  運行過程
     i = 1   8 15 14 2 6 
     i = 2      8 14 15 2 6
     i = 3   target = 2 
              數組變化過程:      8 14 15 15 6
                          8 14 14 15 6
                              8 8 14 15 6
                          arr[0] = target 插入
                          2 8 14 15 6

     i = 4 .....                         
 */

/**
*快速排序
*這是阮一峯的版本，很直觀，感受寫得至關棒！
*    （1）在數據集之中，選擇一個元素做爲"基準"（pivot）。
*
*　　（2）全部小於"基準"的元素，都移到"基準"的左邊；全部大於"基準"的元素，都移到"基準"的右
*     邊。
*
*　　（3）對"基準"左邊和右邊的兩個子集，不斷重複第一步和第二步，直到全部子集只剩下一個元素*     爲止。
* 快速排序是不穩定的，其時間平均時間複雜度是O(nlgn)。
*/
var quickSort = function(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));
}


//快排還有一種更簡便的寫法

function quicksort(arr)
{
    if (arr.length == 0)
        return [];
 
    var left = new Array();
    var right = new Array();
    var pivot = arr[0];
 
    for (var i = 1; i < arr.length; i++) {
        if (arr[i] < pivot) {
           left.push(arr[i]);
        } else {
           right.push(arr[i]);
        }
    }
 
    return quicksort(left).concat(pivot, quicksort(right));
}