排序算法（01）—— 冒泡排序_冒泡算法taptor-CSDN博客

文章目录

前言
算法原理
- 算法原理
- 示例说明
算法分析
- 时间复
- 算法稳定性
算法描述
算法优化

前言

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序错误（如从大到小、首字母从Z到A）就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

算法原理

冒泡排序算法的原理如下：（升序）

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

动态图示：
在这里插入图片描述

冒泡排序流程图如下：
在这里插入图片描述

示例说明

要排序数组:[10,1,35,61,89,36,55]
在这里插入图片描述
第一轮排序：

第一次排序：10和1比较，10大于1，交换位置　　　 [1,10,35,61,89,36,55]
第二次排序：10和35比较，10小于35，不交换位置　　[1,10,35,61,89,36,55]
第三次排序：35和61比较，35小于61，不交换位置　　[1,10,35,61,89,36,55]
第四次排序：61和89比较，61小于89，不交换位置　　[1,10,35,61,89,36,55]
第五次排序：89和36比较，89大于36，交换位置　　　[1,10,35,61,36,89,55]
第六次排序：89和55比较，89大于55，交换位置　　　[1,10,35,61,36,55,89]

第一轮总共进行了六次比较，排序结果：[1,10,35,61,36,55,89]

第二轮排序：

第一次排序：1和10比较，1小于10，不交换位置　　1,10,35,61,36,55,89
第二次排序：10和35比较，10小于35，不交换位置 1,10,35,61,36,55,89
第三次排序：35和61比较，35小于61，不交换位置 1,10,35,61,36,55,89
第四次排序：61和36比较，61大于36，交换位置　　　1,10,35,36,61,55,89
第五次排序：61和55比较，61大于55，交换位置　　　1,10,35,36,55,61,89

第二轮总共进行了5次比较，排序结果：1,10,35,36,55,61,89

第三轮排序：

第一次排序： 1和10比较， 1小于10，不交换位置　　1,10,35,36,55,61,89
第二次排序：10和35比较，10小于35，不交换位置 1,10,35,36,55,61,89
第三次排序：35和36比较，35小于36，不交换位置 1,10,35,36,55,61,89
第四次排序：36和61比较，36小于61，不交换位置　　1,10,35,36,55,61,89

第三轮总共进行了4次比较，排序结果：1,10,35,36,55,61,89

算法分析

时间复

杂度
若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数 C 和记录移动次数 M 均达到最小值：
$C = n - 1 ， M = 0$
所以，冒泡排序最好的时间复杂度为 $O (n)$ 。
若初始文件是反序的，需要进行 n - 1 趟排序。每趟排序要进行 n - i 次关键字的比较 (1 ≤ i ≤ n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：
在这里插入图片描述

冒泡排序的最坏时间复杂度为 $O(n^2)$ 。
综上，因此冒泡排序总的平均时间复杂度为 $O(n^2)$ 。

算法稳定性

冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，是不会再交换的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

算法描述

Java 代码实现

public static int[] bubbleSort(int[] arr) {
    int length = arr.length;
    for (int i = 0; i < length - 1; i++) {
        for (int j = 0; j < length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                int tamp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tamp;
            }
        }
    }
    // Prints result.
    return arr;
}

C 代码实现

#include <stdio.h>
 
#define ARR_LEN 255 /*数组长度上限*/
#define elemType int /*元素类型*/
 
/* 冒泡排序 */
/* 1. 从当前元素起，向后依次比较每一对相邻元素，若逆序则交换 */
/* 2. 对所有元素均重复以上步骤，直至最后一个元素 */
/* elemType arr[]: 排序目标数组; int len: 元素个数 */
void bubbleSort (elemType arr[], int len) {
    elemType temp;
    int i, j;
    for (i=0; i<len-1; i++) /* 外循环为排序趟数，len个数进行len-1趟 */
        for (j=0; j<len-1-i; j++) { /* 内循环为每趟比较的次数，第i趟比较len-i次 */
            if (arr[j] > arr[j+1]) { /* 相邻元素比较，若逆序则交换（升序为左大于右，降序反之） */
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
}
 
int main (void) {
    elemType arr[ARR_LEN] = {3,5,1,-7,4,9,-6,8,10,4};
    int len = 10;
    int i;
     
    bubbleSort (arr, len);
    for (i=0; i<len; i++)
        printf ("%d\t", arr[i]);
    putchar ('\n');
  
    return 0;
}

Python3 代码实现

def bubble_sort(nums):
    for i in range(len(nums) - 1):  # 这个循环负责设置冒泡排序进行的次数
        for j in range(len(nums) - i - 1):  # j为列表下标
            if nums[j] > nums[j + 1]:
                nums[j], nums[j + 1] = nums[j + 1], nums[j]
    return nums
 
print(bubble_sort([45, 32, 8, 33, 12, 22, 19, 97]))
# 输出：[8, 12, 19, 22, 32, 33, 45, 97]

JavaScript 代码实现

function bubbleSort(arr) {
    var i = arr.length, j;
    var tempExchangVal;
    while (i > 0) {
        for (j = 0; j < i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                tempExchangVal = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tempExchangVal;
            }
        }
        i--;
    }
    return arr;
}
 
var arr = [3, 2, 4, 9, 1, 5, 7, 6, 8];
var arrSorted = bubbleSort(arr);
console.log(arrSorted);
alert(arrSorted);

lua 代码实现

function sortBubble(list)
    local len = #list
    for i = 1, len do
        for j = 1, len-i do
            if list[j+1]>list[j] then
                local t = list[j+1]
                list[j+1] = list[j]
                list[j] = t
            end
        end
    end
end

PHP 代码实现

function bubbleSort($numbers) {
    $cnt = count($numbers);
    for ($i = 0; $i < $cnt - 1; $i++) {
        for ($j = 0; $j < $cnt - $i - 1; $j++) {
            if ($numbers[$j] > $numbers[$j + 1]) {
                $temp = $numbers[$j];
                $numbers[$j] = $numbers[$j + 1];
                $numbers[$j + 1] = $temp;
            }
        }
    }
 
    return $numbers;
}
 
$num = array(20, 40, 60, 80, 30, 70, 90, 10, 50, 0);
var_dump(bubbleSort($num));

算法优化

针对问题：
数据的顺序排好之后，冒泡算法仍然会继续进行下一轮的比较，直到arr.length-1次，后面的比较没有意义的。
方案：
设置标志位flag，如果发生了交换flag设置为true；如果没有交换就设置为false。
这样当一轮比较结束后如果flag仍为false，即：这一轮没有发生交换，说明数据的顺序已经排好，没有必要继续进行下去。
以Java为例：

 public void bubbleSortOp(int[] arr) {
        // 临时变量
        int temp;
        // 是否交换的标志
        boolean flag;
        //表示趟数，一共 arr.length-1 次
        for (int i = 0; i < arr.length - 1; i++) {
            // 每次遍历标志位都要先置为false，才能判断后面的元素是否发生了交换
            flag = false;
            //选出该趟排序的最大值往后移动
            for (int j = arr.length - 1; j > i; j--) {
                if (arr[j] < arr[j - 1]) {
                    temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                    flag = true;
                }
            }
            // 判断标志位是否为false，如果为false，说明后面的元素已经有序，就直接return
            if (!flag) {
                break;
            }
        }
    }