冒泡排序是非常经典的一种算法，基本思路就是比较相邻的两个元素的大小，然后交换位置。按从大到小或者从小到大排序。一共要冒泡元素总数减一次，因为每次冒泡都会交换元素位置，当冒泡了n-1次后最大或者最小的元素已经被放到了第一个元素的位置，所以排序已经完成了，没必要再多排一次。因为每一趟冒泡排序都会有一个数被排好，所以第二层循环要排列的数就剩下要冒泡的次数减去已经排列好的元素就只剩下没有排列的元素了。#include <stdio.h>
void maopao(int arr[], int sz) {
int i = 0;
int j = 0;
for (i = 0; i < sz - 1; i++) //总共要冒泡数字总数减一次
{
for (j = 0; j < sz - 1 - i; j++) //剩下的要排列的数就是冒泡次数减去冒泡完的数字
{
if (arr[j] > arr[j + 1])
{
int jh = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = jh;
}
}
}
}
int main() {
int arr[] = { 10, 9, 8, 7, 6, 5, 11, 3, 2, 1, 0 ,6,1};
int sz = sizeof(arr) / sizeof(arr[0]);
printf("冒泡排序前 ");
for (int i = 0; i < sz; i++) {
printf("%d ", arr[i]);
}
printf("\n冒泡排序后 ");
maopao(arr, sz);
for (int j = 0; j < sz; j++) {
printf("%d ", arr[j]);
}
printf("\n");
return 0;
}
只是第一种冒泡排序场景，元素排序没有规定。但如果排序一组已经排好的好的元素这个算法还是一直在那循环循环循环，那不是在做无用功吗？这里介绍第二种场景的冒泡排序场景，但这种方法只能适用于一组有序排列的元素，但它可以不让代码做无用功，只需要在刚才的代码的记住上定义一个flag变量，来判断元素是不是有序的。代码如下#include <stdio.h>
void maopao(int arr[], int sz) {
int i = 0;
int j = 0;
for (i = 0; i < sz - 1; i++)
{//总共要冒泡数字总数减一次
int flag = 1;//定义一个flag变量，来判断是否有序,避免有序数字接着判断
for (j = 0; j < sz - 1 - i; j++)
{//剩下的要排列的数就是冒泡次数减去冒泡完的数字
if (arr[j] > arr[j + 1])
{
int jh = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = jh;
flag = 0;
}
if (flag == 1) {//当数字是有序时直接跳出当前循环
break;
}
}
}
}
int main() {
int arr[] = { 10,9,8,7,6,5,3,2,1,0};
int sz = sizeof(arr) / sizeof(arr[0]);
printf("冒泡排序前 ");
for (int i = 0; i < sz; i++) {
printf("%d ", arr[i]);
}
printf("\n冒泡排序后 ");
maopao(arr, sz);
for (int j = 0; j < sz; j++) {
printf("%d ", arr[j]);
}
printf("\n");
return 0;
}
当相邻两个元素已经是我们需要的排序方式时，则会跳出第二层循环继续判断后面的元素。flag的作用就是对于那种已经排列好的元素，就没必要再排列了。直接跳出循环，且只能用于一组有序排列的元素。这种冒泡排序只能用于整形的排序，如果要排序其他的类型那就要改参数，太麻烦，那有没有一种通用的冒泡排序算法能同时排列整形、浮点形甚至结构体呢？当然有，看我下一条博客！}

冒泡排序动画:手工版// 第一轮 6次 // 45 67 23 88 21 6 99 // 45 23 67 88 21 6 99 // 45 23 67 88 21 6 99 // 45 23 67 21 88 6 99 // 45 23 67 21 6 88 99 // 45 23 67 21 6 88 99 // 第二轮 6次 // 23 45 67 21 6 88 99 // 23 45 67 21 6 88 99 // 23 45 21 67 6 88 99 // 23 45 21 6 67 88 99 // 23 45 21 6 67 88 99 // 23 45 21 6 67 88 99 // 第三轮 6次 // 23 45 21 6 67 88 99 // 23 21 45 6 67 88 99 // 23 21 6 45 67 88 99 // 23 21 6 45 67 88 99 // 23 21 6 45 67 88 99 // 23 21 6 45 67 88 99 // 第四轮 6次 // 21 23 6 45 67 88 99 // 21 6 23 45 67 88 99 // 21 6 23 45 67 88 99 // 21 6 23 45 67 88 99 // 21 6 23 45 67 88 99 // 21 6 23 45 67 88 99 // 第五轮 6次 // 6 21 23 45 67 88 99 // 6 21 23 45 67 88 99 // 6 21 23 45 67 88 99 // 6 21 23 45 67 88 99 // 6 21 23 45 67 88 99 // 6 21 23 45 67 88 99 // 第六轮 6次(这个第6轮即使后面已经成型了 它还是按照程序走一遍) // 6 21 23 45 67 88 99 // 6 21 23 45 67 88 99 // 6 21 23 45 67 88 99 // 6 21 23 45 67 88 99 // 6 21 23 45 67 88 99 // 6 21 23 45 67 88 99 基础版冒泡排序: 简单优化版冒泡排序优化://每轮比较少比较一次。（每一轮都会比较出一个最大值，然后后一轮没有必要再比较了，所以没比较一轮，就少比较一次。。。） j 终极优化版做一个判断 如果在比较的时候 两两不发生比较了 就退出循环 封装一个函数来让外部来选择是哪种排序方法:var arr = [35, 2, 4, 5, 6,5,8,9,99,11]; Array.prototype.mySort = function (fn) { for (var i = 0; i < this.length - 1; i++) { var isSort = true; for (var j = 0; j < this.length - i - 1; j++) { // 封装一个函数让其外部进行选择是哪种方式排序 if (fn(this[j], this[j + 1]) > 0) { isSort = false; var temp = this[j]; this[j] = this[j + 1]; this[j + 1] = temp; } } if (isSort) { break; } } }; arr.mySort(function (a, b) { // 从小到达 return a - b; // 从达到小 return b-a; }); 这里加了判断后可以减少外层循环比如 排序123基础排序为2轮4次-i排序为2轮3次(它只舍去了第二轮循环的第二次比较)bool判断的话为:1轮2次 因为它进行一轮2次比较后发现下一轮没有可比较的了 直接退出循环 输出排序这样大大的提高效率.}