简析冒泡排序

参考：百度百科-冒泡排序（Bubble Sort）
 

算法原理：

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

排序流程图：

 

算法分析：

平均时间复杂度：O(n2)
稳定排序算法

算法实现：

1. C语言版本：

 1 #include "stdio.h"
 2 #include "stdlib.h"
 3 
 4 /*
 5 1. 比较相邻元素，如果第一个比第二个大，就交换它们。
 6 2. 对每一对相邻元素都做同样的工作，从第一对到最后一对。在这一点，最后的元素应该会是最大的数。
 7 3. 针对所有的元素重复以上的步骤，除了最后一个。
 8 4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
 9 */
10 
11 //冒泡排序主循环 需保证不越界
12 void bubbleSort(int arr[], int len)
13 {
14     for (int i = 0; i < len - 1; i++){
15         for (int j = 0; j < len - 1 - i; j++){
16             if (arr[j]>arr[j + 1]){
17                 int tmp = arr[j];
18                 arr[j] = arr[j + 1];
19                 arr[j + 1] = tmp;
20             }
21         }
22     }
23 }
24 
25 //打印数组元素
26 void printBubble(int arr[], int len){
27     for (int i = 0; i<len; i++)
28         printf("%d\t", arr[i]);
29     printf("\n");
30 }
31 
32 int main()
33 {
34     int arr[10] = { 3, 5, 1, -7, 4, 9, -6, 8, 10, 4 };
35     int arrLen = sizeof(arr) / sizeof(arr[0]);
36     //打印原数组
37     printBubble(arr, arrLen);
38     bubbleSort(arr, arrLen);
39     //打印排序后的数组
40     printBubble(arr, arrLen);
41 
42     //暂停终端窗口
43     system("pause");
44     return 0;
45 }

2. C++版本：

 1 #include "iostream"
 2 #include "cstdlib"
 3 using namespace std;
 4 
 5 //冒泡排序主循环
 6 template<typename T> void bubbleSort(T arr[], int len){
 7     for (int i = 0; i < len - 1; i++){
 8         for (int j = 0; j < len - 1 - i; j++){
 9             if (arr[j]>arr[j + 1]){
10                 T tmp = arr[j];
11                 arr[j] = arr[j + 1];
12                 arr[j + 1] = tmp;
13             }
14         }
15     }
16 }
17 
18 //打印数组元素
19 template<typename T> void printBubble(T arr[], int len){
20     for (int i = 0; i<len; i++)
21         cout << arr[i] << ' ';
22     cout << endl;
23 }
24 
25 int main()
26 {
27     //整型测试
28     int arr[] = { 61, 17, 29, 22, 34, 60, 72, 21, 50, 1, 62 };
29     int arrLen = sizeof(arr) / sizeof(arr[0]);
30     
31     //打印原数组
32     printBubble(arr, arrLen);
33     //冒泡排序
34     bubbleSort(arr, arrLen);
35     //打印排序后的数组
36     printBubble(arr, arrLen);
37 
38     //浮点型测试
39     double arrf[] = { 17.5, 19.1, 0.6, 1.9, 10.5, 12.4, 3.8, 19.7, 1.5, 25.4, 28.6, 4.4, 23.8, 5.4 };
40     arrLen = sizeof(arrf) / sizeof(arrf[0]);
41     //打印原数组
42     printBubble(arrf, arrLen);
43     //冒泡排序
44     bubbleSort(arrf, arrLen);
45     //打印排序后的数组
46     printBubble(arrf, arrLen);
47 
48     system("pause");
49     return 0;
50 }

 

 

 

posted @ 2019-06-18 15:20  Jova  阅读(149)  评论(0)  编辑  收藏  举报