排序算法：冒泡排序

已于 2023-01-02 14:21:02 修改

分类专栏：排序算法文章标签：冒泡排序排序算法

于 2021-03-27 17:21:37 首次发布

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

① 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

② 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

③ 针对所有的元素重复以上的步骤，除了最后一个。

④ 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

#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;
}

/* 冒泡排序 */
/* 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;
            }
        }
}

① 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 if (arr[j] > arr[j+1])

② 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

③ 针对所有的元素重复以上的步骤，除了最后一个。 for (j=0; j<len-1-i; j++)

④ 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。for (i=0; i<len-1; i++)

26
点赞
踩
109

收藏

觉得还不错? 一键收藏
6
评论
排序算法：冒泡排序

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

扫一扫

排序算法：冒泡排序

1. 什么是冒泡排序？（摘抄自百度百科）

2. 冒泡排序算法原理（摘抄自百度百科）

3.冒泡排序算法实现（摘抄自百度百科(C语言版)）

下面进行讲解上面的程序：

1. 定义一个类型为(int)排序数组arr

2. 调用bubbleSort(冒泡排序)函数进行排序数组

3. 通过for循环打印排序完后的数组信息

下面进行讲解关键函数bubbleSort：

1. 定义一个类型为(int)的temp临时变量，用于进行数组元素位置之间的交换

2. 定义类型为(int)的i和j，用于数组的外循环和内循环

3. 通过for进行数组的外循环，遍历次数为整个数组的长度

4. 通过for进行数组的内循环，遍历次数为整个数组长度 - 外循环次数

5. 通过if进行比较相邻元素的值，如果后一个元素的值大于当前元素的值则交换两个元素的位置

动画解释

图解：

原始数组

第一次循环

外循环(i)为0, 内循环(j)为0，数组长度(len)为10

内部循环过滤掉已完成排序的元素， for (j=0; j<len-1-i; j++) => for (j=0; j < 10 - 1 - 0; j++) => for (j=0; j < 9; j++)

外循环(i)为0, 内循环(j)为0

执行判断， if (arr[j] > arr[j+1]) => if (arr[0] > arr[1]) => if (3 > 5)，条件为 false，继续执行

外循环(i)为0, 内循环(j)为1

执行判断， if (arr[j] > arr[j+1]) => if (arr[1] > arr[2]) => if (5 > 1)，条件为 true，执行数组元素交换

交换后的数组

外循环(i)为0, 内循环(j)为2

执行判断， if (arr[j] > arr[j+1]) => if (arr[2] > arr[3]) => if (5 > -7)，条件为 true，执行数组元素交换

交换后的数组

外循环(i)为0, 内循环(j)为3

执行判断， if (arr[j] > arr[j+1]) => if (arr[3] > arr[4]) => if (5 > 4)，条件为 true，执行数组元素交换

交换后的数组

外循环(i)为0, 内循环(j)为4

执行判断， if (arr[j] > arr[j+1]) => if (arr[4] > arr[5]) => if (5 > 9)，条件为 false，继续执行

外循环(i)为0, 内循环(j)为5

执行判断， if (arr[j] > arr[j+1]) => if (arr[5] > arr[6]) => if (9 > -6)，条件为 true，执行数组元素交换

交换后的数组

外循环(i)为0, 内循环(j)为6

执行判断， if (arr[j] > arr[j+1]) => if (arr[6] > arr[7]) => if (9 > 8)，条件为 true，执行数组元素交换

交换后的数组

外循环(i)为0, 内循环(j)为7

执行判断， if (arr[j] > arr[j+1]) => if (arr[7] > arr[8]) => if (9 > 10)，条件为 false，继续执行

外循环(i)为0, 内循环(j)为8

执行判断， if (arr[j] > arr[j+1]) => if (arr[8] > arr[9]) => if (10 > 4)，条件为 true，执行数组元素交换

交换后的数组

第一次排序结束

第二次排序开始，数组如下。

外循环(i)为1, 内循环(j)为0，数组长度(len)为10

内部循环过滤掉已完成排序的元素， for (j=0; j<len-1-i; j++) => for (j=0; j < 10 - 1 - 1; j++) => for (j=0; j < 8; j++)

外循环(i)为1, 内循环(j)为0

执行判断， if (arr[j] > arr[j+1]) => if (arr[0] > arr[1]) => if (3 > 1)，条件为 true，执行数组元素交换

交换后的数组

外循环(i)为1, 内循环(j)为1

执行判断， if (arr[j] > arr[j+1]) => if (arr[1] > arr[2]) => if (3 > -7)，条件为 true，执行数组元素交换

交换后的数组

外循环(i)为1, 内循环(j)为2

执行判断， if (arr[j] > arr[j+1]) => if (arr[2] > arr[3]) => if (3 > 4)，条件为 false，继续执行

外循环(i)为1, 内循环(j)为3

执行判断， if (arr[j] > arr[j+1]) => if (arr[3] > arr[4]) => if (4 > 5)，条件为 false，继续执行

外循环(i)为1, 内循环(j)为4

执行判断， if (arr[j] > arr[j+1]) => if (arr[4] > arr[5]) => if (5 > -6)，条件为 true，执行数组元素交换

交换后的数组

外循环(i)为1, 内循环(j)为5

执行判断， if (arr[j] > arr[j+1]) => if (arr[5] > arr[6]) => if (5 > 8)，条件为 false，继续执行

外循环(i)为1, 内循环(j)为6

执行判断， if (arr[j] > arr[j+1]) => if (arr[6] > arr[7]) => if (8 > 9)，条件为 false，继续执行

外循环(i)为1, 内循环(j)为7

执行判断， if (arr[j] > arr[j+1]) => if (arr[7] > arr[8]) => if (9 > 4)，条件为 true，执行数组元素交换

交换后的数组

第二次排序结束

第三次排序开始，数组如下。

外循环(i)为2, 内循环(j)为0，数组长度(len)为10

内部循环过滤掉已完成排序的元素， for (j=0; j<len-1-i; j++) => for (j=0; j < 10 - 1 - 2; j++) => for (j=0; j < 7; j++)

外循环(i)为2, 内循环(j)为0

执行判断， if (arr[j] > arr[j+1]) => if (arr[0] > arr[1]) => if (1 > -7)，条件为 true，执行数组元素交换

交换后的数组

外循环(i)为2, 内循环(j)为1

执行判断， if (arr[j] > arr[j+1]) => if (arr[1] > arr[2]) => if (1 > 3)，条件为 false，继续执行

外循环(i)为2, 内循环(j)为2

执行判断， if (arr[j] > arr[j+1]) => if (arr[2] > arr[3]) => if (3 > 4)，条件为 false，继续执行

外循环(i)为2, 内循环(j)为3