排序算法之冒泡排序

冒泡排序：通过n-1轮外层循环，每第 i 轮外层循环都会有一个n-1-i轮内层循环，且每一轮内层循环将无序序列的最大或最小的一个数，需要通过两两对比、交换的方式（可能存在多次位置交换）逐渐冒泡移动、增加到有序序列中。直到无序序列只剩最后一个最大或最小的数，默认进入有序序列，排序结束。

//冒泡排序

const NumberArr = [2, 2, 1, 6, 52, 4, 5, 8, 9, 17, 3];

/**
 * 升幂排序，进行n-1次排序，第n轮因为前面n-1个元素都排好序，只剩一个元素不需要比较排序
 * 每一轮比较元素，不需要比较已经排序好的元素。所以减掉了很多重复排序
 * @param {*} arr 未排序的数组
 * @returns arr 已经排序好的数组
 */
function buddle_arr_asc(arr) {
    for (let i = 0; i < arr.length - 1; i++) {
        for (let j = 0; j < arr.length - (i + 1); j++) {
            if (arr[j] > arr[j + 1]) {
                let temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    return arr;
}


/**
 * 降幂排序，进行n-1次排序，第n轮因为前面n-1个元素都排好序，只剩一个元素不需要比较排序
 * 每一轮比较元素，不需要比较已经排序好的元素。所以减掉了很多重复排序
 * @param {*} arr 未排序的数组
 * @returns arr 已经排序好的数组
 */
function buddle_arr_desc(arr) {
    for (let i = 0; i < arr.length - 1; i++) {
        for (let j = 0; j < arr.length - (i + 1); j++) {
            if (arr[j] < arr[j + 1]) {
                let temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    return arr;
}

最坏情况——逆序：需要进行n(n-1)/2次比较，n-1次排序，n(n-1)/2次记录的移动，时间复杂度为O(n^2)。

最好情况——正序：需要进行n-1次比较，0次排序，0次移动，时间复杂度为O(n)。

稳定性：冒泡排序交换的是相邻的两个元素，如果两个元素相等，是不会交换两个元素的位置的，所以冒泡排序是稳定的。