Javascript实现各类数组排序算法

Javascript代码：

/**
 * Created by qiuleo on 15/6/17.
 */

/**
 * @description 生成随机数的数组，用作排序测试使用
 * @param len
 * @param from
 * @param to
 * @returns {Array}
 */
function makeRandArr(len, from, to) {
    from = from || 0;
    to = to || 100;
    var result = [], i = 0;
    if (len == 0) {
        return [];
    }
    for (; i < len; i++) {
        result.push(Math.floor(Math.random() * ( to - from + 1) - from));
    }
    return result;
}

/**
 * @description 定义console对象的timeStat计时器
 */
function defineConsoleTime() {
    if (typeof console.timeStat === 'undefined') {
        Object.defineProperty(console, 'timeStat', {
            writeable: true,
            enumerable: false,
            configurable: false,
            value: function () {
                var spent;
                if (this.timeStampStat === undefined) {
                    this.timeStampStat = Date.now();
                    spent = 0;
                } else {
                    var spent = Date.now() - this.timeStampStat;
                    this.timeStampStat = Date.now();
                }
                return spent;
            }
        });
    }

}

/**
 * @description 测试函数 runTest(bubbleSort, 'desc', 30);
 * @param sortfunction
 * @param dir
 * @param arrlen
 * @param from
 * @param to
 */
function runTest(sortfunction, dir, arrlen, from, to) {
    arrlen = arrlen || 1000;
    var arr = makeRandArr(arrlen, from, to);
    if (arr === []) {
        throw TypeError('Array\'s len must be great than zero');
    }
    if (typeof sortfunction !== 'function') {
        throw TypeError('Function `' + sortfunction + '` have not defined yet');
    }
    defineConsoleTime();
    console.timeStat();
    var arg = [arr, dir];
    var result = sortfunction.apply(null, arg);
    console.log(result);
    console.log('Array\'s length is ' + result.length + ', spent times : ', console.timeStat());
}

/**
 * @description 快速排序实现
 * @param arr
 * @param dir
 * @returns {*}
 */
function quickSort(arr, dir) {
    dir = dir || 'asc';
    if (arr.length === 0) {
        return [];
    }
    var left = [], right = [], first = arr[0], i = 1;
    if (dir === 'asc') {
        for (; i < arr.length; i++) {
            arr[i] < first ? left.push(arr[i]) : right.push(arr[i]);
        }
    } else {
        for (; i < arr.length; i++) {
            arr[i] > first ? left.push(arr[i]) : right.push(arr[i]);
        }
    }

    return sort(left, dir).concat(first, sort(right, dir));
}

/**
 * @description 插入排序算法实现
 *  时间复杂度：如果目标是把n个元素的序列升序排列，那么采用插入排序存在最好情况和最坏情况。
 *  最好情况就是，序列已经是升序排列了，在这种情况下，需要进行的比较操作需(n-1)次即可。
 *  最坏情况就是，序列是降序排列，那么此时需要进行的比较共有n(n-1)/2次。
 *  插入排序的赋值操作是比较操作的次数加上 (n-1)次。平均来说插入排序算法的时间复杂度为O(n^2)。
 *  因而，插入排序不适合对于数据量比较大的排序应用。但是，如果需要排序的数据量很小，
 *  例如，量级小于1000，那么插入排序还是一个不错的选择。
 * @param arr
 * @param dir
 * @returns {*}
 */
function insertSort(arr, dir) {
    var len = arr.length, dir = dir || 'asc', i = 1, tmp, j;
    if (!len) {
        return [];
    }
    if (dir === 'asc') {
        for (; i < len; i++) {
            tmp = arr[i];
            j = i - 1;
            while (arr[j] > tmp) {
                arr[j + 1] = arr[j];
                arr[j] = tmp;
                j--;
            }
        }
    } else {
        for (; i < len; i++) {
            tmp = arr[i];
            j = i - 1;
            while (arr[j] < tmp) {
                arr[j + 1] = arr[j];
                arr[j] = tmp;
                j--;
            }
        }
    }
    return arr;
}

/**
 * @description 选择排序算法实现
 *  每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
 * @param arr
 * @param dir
 */
function selectSort(arr, dir) {
    var len = arr.length, dir = dir || 'asc', i = 0, k, tmp, j;
    if (!len) {
        return [];
    }
    if (dir === 'asc') {
        for (; i < len; i++) {
            for (j = i + 1; j < len; j++) {
                if (arr[i] > arr[j]) {
                    tmp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = tmp;
                }
            }
        }
    } else {
        for (; i < len; i++) {
            for (j = i + 1; j < len; j++) {
                if (arr[i] < arr[j]) {
                    tmp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = tmp;
                }
            }
        }
    }
    return arr;
}

/**
 * @description 冒泡排序算法实现
 *  两两比较待排序数据元素的大小，发现两个数据元素的次序相反时即进行交换，直到没有反序的数据元素为止。
 *  该算法的时间复杂度为O(n2)。但是，当原始关键字序列已有序时，只进行一趟比较就结束，此时时间复杂度为O(n)。
 * @param arr
 * @param dir
 */
function bubbleSort(arr, dir) {
    var len = arr.length, dir = dir || 'asc', i, j, tmp;
    if (!len) {
        return [];
    }
    if (dir === 'asc') {
        for (i = 0; i < len; i++) {
            for (j = len - 1; j > i; j--) {
                if (arr[j] < arr[j - 1]) {
                    tmp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = tmp;
                }
            }
        }
    }else{
        for (i = 0; i < len; i++) {
            for (j = len - 1; j > i; j--) {
                if (arr[j] > arr[j - 1]) {
                    tmp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = tmp;
                }
            }
        }
    }

    return arr;
}

/**
 * @description 堆排序算法实现
 * @param arr
 * @param dir
 */
function heapSort(arr, dir) {

}

/**
 * @description 归并算法实现
 * @param arr
 * @param dir
 */
function mergeSort(arr, dir) {

}

/**
 * @description 基数算法实现
 * @param arr
 * @param dir
 */
function radixSort(arr, dir) {

}

runTest(bubbleSort, 'desc', 30);