冒泡排序以及改进

关于排序术语：

内排序：排序数据放置在内存中，排序操作在内存中进行

外排序：排序数据放置在磁盘中，通过磁盘和内存进行的数据传输进行排序操作

 

时间复杂度：算法执行所消耗的时间

空间复杂度：运行完一个程序所需内存的大小

 

冒泡排序 

function bubbleSort(arr) {
    // 记录传入数组的长度
    let len = arr.length
    let temp = 0
    // 外循环：
    for (let i = 0; i < len; i++) {
      // 内循环：
      for (let j = 0; j < len - 1 - i; j++) {
        // 相邻元素元素两两对比，如果前面的数大于后面的数，则进行位置互换
        // 这里假定一个例子： 此刻 [..., 5, 3, ...]
        // arr[j] = 5
        // arr[j + 1] = 3
        if (arr[j] > arr[j + 1]) {
          // 位置互换

          // 临时变量，将arr[j + 1] 即3存储起来，temp = 3
          temp = arr[j + 1]

          // 对arr[j + 1]进行赋值，变为前面的数值arr[j]，即 arr[j + 1] = 5
          arr[j + 1] = arr[j]

          // 最后将前面的arr[j]设置为临时变量存起来的数值3，arr[j] = 3
          arr[j] = temp
        }
        // 此刻，数组变成： [..., 3, 5, ...]
      }
      // 关于上面 j < len - 1 - i
      // 例子：
      // [3, 2, 5, 9, 4], length = 5
      // 外循环第一遍
      // 开始[3, 2, 5, 9, 4], 第1次, j = 0, arr[j] = 3, arr[j+1] = 2, 3 > 2, true ,  变动 => [2, 3, 5, 9, 4]
      // 开始[2, 3, 5, 9, 4], 第2次, j = 1, arr[j] = 3, arr[j+1] = 5, 3 > 5, false , 不变 => [2, 3, 5, 9, 4]
      // 开始[2, 3, 5, 9, 4], 第3次, j = 2, arr[j] = 5, arr[j+1] = 9, 5 > 9, false , 不变 => [2, 3, 5, 9, 4]
      // 开始[2, 3, 5, 9, 4], 第3次, j = 3, arr[j] = 9, arr[j+1] = 4, 9 > 4, true ,  变动 => [2, 3, 5, 4, 9]

      // 开始[2, 3, 5, 4, 9]，第5次，j = 4， arr[j] = 9， arr[j + 1] = undefined，9 > ?
      // 到达第5次，只有arr[j]，但是没有arr[j + 1]，所以这一步没有意义，因此这是len - 1 的理由

      // 可以看到，外循环第一遍之后，会把数组中的最大数即9，推到数组最后一位
      // 因为外循环第二遍的时候，数组[2, 3, 5, 9, 4]已经没有必要把最后一位9加入排序操作
      // i = 0 外循环第一遍还没有开始排序，所以可排序长度： - 0
      // i = 1 外循环第二遍开始排序了一位，所以可排序长度： - 1
      // 这便是len - 1 - i的理由
    }
    // 最后返回处理完的数组
    return arr
}
let arr = [3, 2, 5, 9, 4]
console.log(bubbleSort(arr)) // [2, 3, 4, 5, 9]

改进冒泡一：通过记录交换位置排序

function bubbleSortByPos(arr) {
    // 初始时的长度需要 - 1，
    // 比如数组有5个数据 for循环对比时 arr[4]即是最后一个数据
    // 没有对比的需要，所以需要长度 - 1， 使得最后一次是a[3]与a[4]对比
    let len = arr.length - 1
    let temp = 0
    // while循环
    while(len > 0) {
        // 每次循环，交换位置初始值都是从0开始
        let pos = 0
        // 内循环
        for (let j = 0; j < len; j++) {
            // 相邻元素两两对比，如果前面的数大于后面的数，则位置进行互换
            // 这里假定一个例子：此刻[..., 5, 3, ...]
            // arr[j] = 5
            // aarr[j+1] = 3
            if (arr[j] > arr[j+1]) {
                // 当满足前面的数大于后面的数这个条件时，记录下当前的交换位置
                pos = j

                // 位置交互
                // 声明一个temp临时变量，将后面的数arr[j+1]即3存起来：temp=3
                temp = arr[j+1]

                // 对后面的数arr[j+1]进行赋值，变为前面的数值arr[j]: arr[j+1] = 5
                arr[j+1] = arr[j]

                // 最后将前面的数值arr[j]设置为临时变量存储起来的数值5: arr[j] = 3
                arr[j] = temp
            }
            // 此刻，数组变成：[..., 3, 5, ...]
        }
        // 本次for循环之后，可以得到本次for循环最终的交换位置pos，
        // 该交换位置（不包含该位置）后面的都是排序好的，
        // 所以该pos的值即是下一个for循环开始时，
        // 该数组的截断点，截断点之前的数据都要再一次参与排序
        len = pos

        // 例子：
        // [5, 4, 6, 2, 7, 8, 9], length = 7
        // while循环
        // for循环
        // 开始[5, 4, 6, 2, 7, 8, 9], 第1次, j = 0, arr[j] = 5, arr[j+1] = 4, 5 > 4, true , 变动 => [4, 5, 6, 2, 7, 8, 9]  pos = j = 0
        // 开始[4, 5, 6, 2, 7, 8, 9], 第2次, j = 1, arr[j] = 5, arr[j+1] = 6, 5 > 6, false, 不变 => [4, 5, 6, 2, 7, 8, 9]  pos = j = 0
        // 开始[4, 5, 6, 2, 7, 8, 9], 第3次, j = 2, arr[j] = 6, arr[j+1] = 2, 6 > 2, true , 变动 => [4, 5, 2, 6, 7, 8, 9]  pos = j = 2
        // 开始[4, 5, 2, 6, 7, 8, 9], 第4次, j = 3, arr[j] = 6, arr[j+1] = 7, 6 > 7, false, 不变 => [4, 5, 2, 6, 7, 8, 9]  pos = j = 0
        // 开始[4, 5, 2, 6, 7, 8, 9], 第5次, j = 4, arr[j] = 7, arr[j+1] = 8, 7 > 8, false, 不变 => [4, 5, 2, 6, 7, 8, 9]  pos = j = 0
        // 开始[4, 5, 2, 6, 7, 8, 9], 第6次, j = 5, arr[j] = 8, arr[j+1] = 9, 8 > 9, false, 不变 => [4, 5, 2, 6, 7, 8, 9]  pos = j = 0

        // 可以看到本次for循环最终交换位置为数组下标序号2，下标2后面的数据都是排序好的，所以下标2（包含）前面的数据要进入下一次排序操作
    }
    // 最后返回处理完的数组
    return arr
}
let arr = [5, 4, 6, 2, 7, 8, 9]
console.log(bubbleSortByPos(arr)) // [2, 4, 5, 6, 7, 8, 9]

改进冒泡二：正反方向串行排序

function bubbleSortByLowAndHigh(arr) {
    // 初始最小序号值
    let low = 0
    // 初始时的长度需要 - 1，
    // 比如数组有5个数据 for循环对比时 arr[4]即是最后一个数据
    // 没有对比的需要，所以需要长度 - 1， 使得最后一次是a[3]与a[4]对比
    let high = arr.length - 1

    let temp, j
    // while循环， 当最小序号值小于最大序号值，才继续循环，否则说明已经排序完毕
    while(low < high) {
        // 从上一次排序好的最小序号位置开始，从上一次排序好的最大的序号值结束，找到最大值
        for (j = low; j < high; j++) {
            // 相邻元素两两对比，如果前面的数大于后面的数，则位置进行互换
            // 这里假定一个例子：此刻[..., 5, 3, ...]
            // arr[j] = 5
            // aarr[j+1] = 3
            if (arr[j] > arr[j+1]) {
                // 位置交互
                // 将后面的数arr[j+1]即3存起来：temp=3
                temp = arr[j+1]
                // 对后面的数arr[j+1]进行赋值，变为前面的数值arr[j]: arr[j+1] = 5
                arr[j+1] = arr[j]
                // 最后将前面的数值arr[j]设置为临时变量存储起来的数值3: arr[j] = 3
                arr[j] = temp
            }
        }
        // 本次for循环找到最大值，并被置换到相应的排序好后的位置，arr数组可排序数组最大序号值减1
        high--

        // 从上一次排序好的最大序号位置开始，从上一次排序好的最小的序号值结束，找到最小值
        for (j = high; j > low; j--) {
            // 相邻元素两两对比，如果前面的数大于后面的数，则位置进行互换
            // 这里假定一个例子：此刻[..., 5, 3, ...]
            // arr[j-1] = 5
            // aarr[j] = 3
            if (arr[j-1] > arr[j]) {
                // 位置交互
                // 将后面的数arr[j]即3存起来：temp=3
                temp = arr[j]
                // 对后面的数arr[j]进行赋值，变为前面的数值arr[j-1]: arr[j] = 5
                arr[j] = arr[j-1]
                // 最后将前面的数值arr[j-1]设置为临时变量存储起来的数值3: arr[j] = 3
                arr[j-1] = temp
            }
        }
        // 本次for循环找到最小值，并被置换到相应的排序好后的位置，arr数组可排序数组最小序号值加1
        low++

        // 例子：
        // [5, 4, 6, 2, 7, 9, 8], length = 7  high = length - 1 = 6
        // while循环
        // 第一个for循环
        // 开始[5, 4, 6, 2, 7, 9, 8], 第1次, j = 0, arr[j] = 5, arr[j+1] = 4, 5 > 4, true , 变动 => [4, 5, 6, 2, 7, 9, 8]
        // 开始[4, 5, 6, 2, 7, 9, 8], 第2次, j = 1, arr[j] = 5, arr[j+1] = 6, 5 > 6, false, 不变 => [4, 5, 6, 2, 7, 9, 8]
        // 开始[4, 5, 6, 2, 7, 9, 8], 第3次, j = 2, arr[j] = 6, arr[j+1] = 2, 6 > 2, true , 变动 => [4, 5, 2, 6, 7, 9, 8]
        // 开始[4, 5, 2, 6, 7, 9, 8], 第4次, j = 3, arr[j] = 6, arr[j+1] = 7, 6 > 7, false, 不变 => [4, 5, 2, 6, 7, 9, 8]
        // 开始[4, 5, 2, 6, 7, 9, 8], 第5次, j = 4, arr[j] = 7, arr[j+1] = 9, 7 > 9, false, 不变 => [4, 5, 2, 6, 7, 9, 8]
        // 开始[4, 5, 2, 6, 7, 9, 8], 第6次, j = 5, arr[j] = 9, arr[j+1] = 8, 9 > 8, true,  变动 => [4, 5, 2, 6, 7, 8, 9]
        // 可以看到本次for循环得到最大值为9，最大序号为high = 6
        // 此时序号为6的值为最大值，不必进入下一次排序操作，high需要减1，可排序数组数据减少一位， high--

        // [4, 5, 2, 6, 7, 8], low = 0 high = 5        
        // 第二个for循环
        // 开始[4, 5, 2, 6, 7, 8], 第1次, j = 5, arr[j-1] = 7, arr[j] = 8, 7 > 8, false, 不变 => [4, 5, 2, 6, 7, 8]
        // 开始[4, 5, 2, 6, 7, 8], 第2次, j = 4, arr[j-1] = 6, arr[j] = 7, 6 > 7, false, 不变 => [4, 5, 2, 6, 7, 8]
        // 开始[4, 5, 2, 6, 7, 8], 第3次, j = 3, arr[j-1] = 2, arr[j] = 6, 2 > 6, false, 不变 => [4, 5, 2, 6, 7, 8]
        // 开始[4, 5, 2, 6, 7, 8], 第4次, j = 2, arr[j-1] = 5, arr[j] = 2, 5 > 2, true , 变动 => [4, 2, 5, 6, 7, 8]
        // 开始[4, 2, 5, 6, 7, 8], 第5次, j = 1, arr[j-1] = 4, arr[j] = 2, 4 > 2, true , 变动 => [2, 4, 5, 6, 7, 8]

        // 可以看到本次for循环得到最小值为2，最小序号为low = 0
        // 此时序号为0的值为最小值，不必进入下一次排序操作，low需要加1，可排序数组数据减少一位， low++

        // 进入下一次while循环
    }
    // 最后返回处理完的数组
    return arr
}
let arr = [3,55,38,5,87,15,34,14,27,2,46,3,25,50,28]
console.log(bubbleSortByLowAndHigh(arr)) // [2, 3, 3, 5, 14, 15, 25, 27, 28, 34, 38, 46, 50, 55, 87]