算法——经典排序算法

一.冒泡排序

时间复杂度：O(n2)
稳定性：稳定

function bubbleSort(arr) { 
    var len = arr.length; 
    for (var i = 0; i < len; i++) { 
        for (var j = 0; j < len - 1 - i; j++) { 
            if (arr[j] > arr[j+1]) {        //相邻元素两两对比 
                var temp = arr[j+1];        //元素交换 
                arr[j+1] = arr[j]; 
                arr[j] = temp; 
            } 
        } 
    } 
    return arr; 
} 
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48]; 
console.log(bubbleSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]  

二.选择排序

时间复杂度：O(n2)
稳定性：稳定

function selectionSort(arr) { 
    var len = arr.length; 
    var minIndex, temp; 
    for (var i = 0; i < len - 1; i++) { 
        minIndex = i; 
        for (var j = i + 1; j < len; j++) { 
            if (arr[j] < arr[minIndex]) {     //寻找最小的数 
                minIndex = j;                 //将最小数的索引保存 
            } 
        } 
        temp = arr[i]; 
        arr[i] = arr[minIndex]; 
        arr[minIndex] = temp; 
    } 
    return arr; 
} 
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48]; 
console.log(selectionSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50] 

三.插入排序

时间复杂度：O(n2)
稳定性：稳定

function insertionSort(array) {
    for (var i = 1; i < array.length; i++) {
        var key = array[i];
        var j = i - 1;
        while (j >= 0 && array[j] > key) {
            array[j + 1] = array[j];
            j--;
        }
        array[j + 1] = key;
    }
    return array;
}
var arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48];
console.log(insertionSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50] 

四.希尔排序

时间复杂度：O(n2)
稳定性：不稳定

function shellSort(arr) { 
    var len = arr.length, 
        temp, 
        gap = 1;   
    while(gap < len/5) {          //动态定义间隔序列 
        gap =gap*5+1; 
    } 
    for (gap; gap > 0; gap = Math.floor(gap/5)) { 
        for (var i = gap; i < len; i++) { 
            temp = arr[i]; 
            for (var j = i-gap; j >= 0 && arr[j] > temp; j-=gap) { 
                arr[j+gap] = arr[j]; 
            } 
            arr[j+gap] = temp; 
        } 
    } 
    return arr; 
} 
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48]; 
console.log(shellSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

五.归并排序

时间复杂度：O(nlog2n)
稳定性：稳定

function mergeSort(arr) {  //采用自上而下的递归方法 
    var len = arr.length; 
    if(len < 2) { 
        return arr; 
    } 
    var middle = Math.floor(len / 2), 
        left = arr.slice(0, middle), 
        right = arr.slice(middle); 
    return merge(mergeSort(left), mergeSort(right)); 
} 
function merge(left, right) 
{ 
    var result = []; 
    while (left.length && right.length) { 
        if (left[0] <= right[0]) { 
            result.push(left.shift()); 
        } else { 
            result.push(right.shift()); 
        } 
    } 
    while (left.length) 
        result.push(left.shift()); 
    while (right.length) 
        result.push(right.shift()); 
    return result; 
} 
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48]; 
console.log(mergeSort(arr));

六.快速排序

时间复杂度：O(n2)
稳定性：不稳定

function quickSort(array, left, right) {
    if (left < right) {
        var x = array[right], i = left - 1, temp;
        for (var j = left; j <= right; j++) {
            if (array[j] <= x) {
                i++;
                temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
        quickSort(array, left, i - 1);
        quickSort(array, i + 1, right);
    }
    return array;
}
var arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48];
console.log(quickSort(arr, 0, arr.length - 1));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

七.堆排序

时间复杂度：O(nlog2n)
稳定性：不稳定

function heapSort(array) {
    console.time('堆排序耗时');
        //建堆
        var heapSize = array.length, temp;
        for (var i = Math.floor(heapSize / 2) - 1; i >= 0; i--) {
            heapify(array, i, heapSize);
        }
        //堆排序
        for (var j = heapSize - 1; j >= 1; j--) {
            temp = array[0];
            array[0] = array[j];
            array[j] = temp;
            heapify(array, 0, --heapSize);
        }
        console.timeEnd('堆排序耗时');
        return array;
}
function heapify(arr, x, len) {
        var l = 2 * x + 1, r = 2 * x + 2, largest = x, temp;
        if (l < len && arr[l] > arr[largest]) {
            largest = l;
        }
        if (r < len && arr[r] > arr[largest]) {
            largest = r;
        }
        if (largest != x) {
            temp = arr[x];
            arr[x] = arr[largest];
            arr[largest] = temp;
            heapify(arr, largest, len);
        }
}
var arr=[91,60,96,13,35,65,46,65,10,30,20,31,77,81,22];
console.log(heapSort(arr));//[10, 13, 20, 22, 30, 31, 35, 46, 60, 65, 65, 77, 81, 91, 96]

八.基数排序

时间复杂度：O(d(n+r))
稳定性：稳定

function radixSort(arr, maxDigit) {
    var mod = 10;
    var dev = 1;
    var counter = [];
    console.time('基数排序耗时');
    for (var i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
        for(var j = 0; j < arr.length; j++) {
            var bucket = parseInt((arr[j] % mod) / dev);
            if(counter[bucket]== null) {
                counter[bucket] = [];
            }
            counter[bucket].push(arr[j]);
        }
        var pos = 0;
        for(var j = 0; j < counter.length; j++) {
            var value = null;
            if(counter[j]!=null) {
                while ((value = counter[j].shift()) != null) {
                      arr[pos++] = value;
                }
          }
        }
    }
    console.timeEnd('基数排序耗时');
    return arr;
}
var arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48];
console.log(radixSort(arr,2)); //[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]