冒泡排序（普通，加强对比）

1.普通的冒泡排序

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<iostream>
 3 #include<time.h>
 4 using namespace std;
 5 #define MAX 20
 6 //打印数组
 7 void printFunc(int* arr, int len)
 8 {
 9     for (int i = 0; i < len; i++)
10         cout << arr[i] << " ";
11     cout << endl;
12 }
13 //排序
14 void Popsort(int* arr, int len)
15 {
16     //从小到大
17     for (int i = 0; i < len-1; i++)　　　　　　　　　　　　//要点1.
18     {
19         for (int j = 0; j < len - i - 1; j++)　　　　　　//要点2.
20         {
21             if (arr[j] > arr[j + 1])　　　　　　　　　　　//要点3.
22             {
23                 int temp = arr[j];
24                 arr[j] = arr[j+1];
25                 arr[j + 1] = temp;
26             }
27         }
28     }
29
30 }
31 //创建数组
32 void test03()
33 {
34     int arr[MAX];
35     srand((unsigned int)time(NULL));
36     for (int i = 0; i < MAX; i++)
37     {
38         arr[i] = rand() % MAX;
39     }
40     printFunc(arr, MAX);
41     //排序
42     Popsort(arr, MAX);
43     printFunc(arr, MAX);
44
45 }
46
47
48 int main03()
49 {
50
51     test03();
52
53     system("pause");
54     return EXIT_SUCCESS;
55 }

2.加强版冒泡排序

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<iostream>
 3 #include<time.h>
 4 using namespace std;
 5 #define MAX 20
 6 //打印数组
 7 void printFunc04(int* arr, int len)
 8 {
 9     for (int i = 0; i < len; i++)
10         cout << arr[i] << " ";
11     cout << endl;
12 }
13 //排序
14 void Popsort04(int* arr, int len)
15 {
16     bool flag = true;　　　　　　　　　　　　// 要点1.
17     for (int i = 0; i < len - 1 && flag; i++)
18     {
19         flag = false;　　　　　　　　　　　　// 要点2.
20         for (int j = 0; j < len - 1 - i; j++)
21         {
22             if (arr[j] > arr[j + 1])　　　　//要点3.
23             {
24                 flag = true;
25                 int temp = arr[j];
26                 arr[j] = arr[j + 1];
27                 arr[j + 1] = temp;
28             }
29         }
30     }
31     cout << "新冒泡" << endl;
32 }
33
34
35 //创建数组
36 void test04()
37 {
38     int arr[MAX];
39     srand((unsigned int)time(NULL));
40     for (int i = 0; i < MAX; i++)
41     {
42         arr[i] = rand() % MAX;
43     }
44     printFunc04(arr, MAX);
45     //排序
46     Popsort04(arr, MAX);
47     printFunc04(arr, MAX);
48
49 }
50 int main()
51 {
52
53     test04();
54
55     system("pause");
56     return EXIT_SUCCESS;
57 }

//这两种方法的不同之处在于：（进行排序的次数会不同）

1.普通冒泡： 即使数据是有序的，或排序过程中（还没有进行完，已经有序），但是剩下的排序步骤它还会进行，浪费时间。

2.加强版冒泡：增加了一个标示量（flag）；一旦当数组有序后，标示量就变为 false，不会在进行下面的循环，节省了循环次数。

加强版：详细理解（参照上面代码：）

　　1）标示量 flag 初始值为 true， 他会进入外层循环，然后就给他赋值为 false；

　　2）当在内层循环时，如果此时数据有序，就不会进入 if（）判断语句；标示量就不会发生变化， 还为false， 下一次外层循环就不会进入，减少了循环次数

　　3）如果此时数据无序， 在内层循环时， 会进入if（）判断语句，标示量 发生变化，为 true， 下一次外层循环还会进入， 直至 false为 true 或者 全部循环完毕（此时false肯定也为true了， 因为已经排序完， 数据一定有序了）。

3.冒泡循环的特点：

　　1.）每次内层循环完毕，都会把数据中（最大或最小）的元素放到指定的位置

　　2.）如第一次内层循环完毕，数据中（最大或最小） 的元素肯定实在数据的开头或结尾（一般是开头，因为大部分人都是从开头进行循环的）。