排序算法 nodeJS

排序算法

nodeJS代码

/**
 * 冒泡排序
 * @param arr 数组
 * @param num 大于 0 由大到小 ， 小于 0 由小到大
 * @returns {*} 排序后数组
 */
let bubbleSort = function bubbleSort(arr, num) {
    /**
     * 冒泡排序(Bubble Sorting)的基本思想
     * 通过对待排序序列从前向后(从下标较小的元素开始),依次比较相邻元素的值,
     * 若发现逆序则交换,使值较大的元素逐渐从前移向后部,就象水底下的气泡一样逐渐向上冒。
     *
     * 优化
     * 因为排序的过程中,各元素不断接近自己的位置,如果一趟比较下来没有进行过交换,
     * 就说明序列有序,因此要在排序过程中设置个标志flag判断元素是否进行过交换。从而减少不必要的比较
     *
     * 小结冒泡排序规则
     * (1)一共进行数组的大小1次大的循环
     * (2)每一趟排序的次数在逐渐的属少
     * (3)如果我们发现在某趟排序中,没有发生一次交换,可以提前结束冒泡排序。这个就是优化
     */
    console.log("冒泡排序");
    if (num > 0) {
        let max = arr.length;
        let temp;//临时变量
        while (max > 0) {
            let flag = true;
            for (let i = 0; i < max - 1; i++) {
                if (arr[i] < arr[i + 1]) {
                    temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                    flag = false;
                }
            }
            max--;
            if (flag) {
                break;
            }
        }
    } else if (num < 0) {
        let max = arr.length;
        let temp;
        while (max > 0) {
            let flag = true;
            for (let i = 0; i < max - 1; i++) {
                if (arr[i] > arr[i + 1]) {
                    temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                    flag = false;
                }
            }
            max--;
            if (flag) {
                break;
            }
        }
    }
    return arr;
};

/**
 * 选择排序
 * @param arr 数组
 * @param num 大于 0 由大到小 ， 小于 0 由小到大
 * @returns {*} 排序后数组
 */
let selectSort = function selectSort(arr, num) {
    /**
     * 基本思想
     * 第一次从arr[0]~arr[n-1]中选最小值，与arr[0]交换，
     * 第二次从arr[1] arr[n-1]中选最小值, 与arr[1]交换，
     * 第三次从arr[2]~arr[n-1]中选取最小值，与arr[2]交换
     * 第n-1次从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]交换，总共通过n-1次，
     * 得到一个排序码从小到大排列的有序序列
     *
     * 说明
     * 1. 选择排序一共有数组大小-1轮排序
     * 2. 每一轮爱旭，又是一个循环，循环的规则(代码)
     * 2.1先假定当前这个数是最小数
     * 2.2然后和后面的每个数进行比较,如果发现有比当前数更小的数,就重新确定最小数，并得到下标
     * 2.3当遍历到数组的最后时,就得到本轮最小数和下标
     * 2.4交换(代码)
     */
    console.log("选择排序");
    if (num > 0) {
        for (let i = 0; i < arr.length - 1; i++) {
            let maxIndex = i;
            let max = arr[i];
            for (let j = i + 1; j < arr.length; j++) {
                if (max < arr[j]) {//说明假定的最大值不是最大的
                    max = arr[j];//重置min
                    maxIndex = j;//重置minIndex
                }
            }
            if (maxIndex != i) {
                arr[maxIndex] = arr[i];
                arr[i] = max;
            }
        }
    } else if (num < 0) {
        for (let i = 0; i < arr.length - 1; i++) {
            let minIndex = i;
            let min = arr[i];
            for (let j = i; j < arr.length;