排序算法

冒泡排序

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

选择排序

function selectionSort(arr) {
    var len = arr.length;
    var minIndex,temp;
    for(var i=0; i<len; 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;
}

插入排序

function insertionSort(arr) {
    var len = arr.length;
    var preIndex, current;
    for (var i=1; i<len; i++) {
        preIndex = i-1;
        current = arr[i];
        while(preIndex >= 0 && arr[preIndex] > current) {
            arr[preIndex+1] = arr[preIndex];
            preIndex--;
        }
        arr[preIndex+1] = current;
    }
    return arr;
}

归并排序

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>0 && right.length>0) {
        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;
}

快速排序

function quickSort(arr,left,right) {
    var len = arr.length,
        partitionIndex,
        left = typeof left !='number' ? 0 : left;
        right = typeof right !='number' ? len - 1 :right;

    if(left < right) {
        partitionIndex = partition(arr, left, right);
        quickSort(arr, left, partitionIndex-1);
        quickSort(arr, partitionIndex+1, right);
    }
    return arr;
}

function partition(arr, left , right) {
    var pivot = left,
        index = pivot+1;
    for (var i=index; i<=right; i++) {
        if (arr[i] < arr[pivot]) {
            swap(arr,i,index);
            index++;
        }
    }
    swap(arr, pivot, index-1);
    return index-1;
}

function swap(arr, i, j) {
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

计数排序

function countingSort(arr,maxValue) {
    var bucket = new Array(maxValue+1),
        sortedIndex = 0,
        arrLen = arr.length,
        bucketLen = maxValue + 1;

    for (var i=0; i<arrLen; i++) {
        if(!bucket[arr[i]]) {
            bucket[arr[i]] = 0;
        }
        bucket[arr[i]]++;
    }
    for (var j=1; j<bucketLen; j++) {
        while(bucket[j] > 0) {
            arr[sortedIndex++] = j;
            bucket[j]--;
        }
    }
    return arr;
}