黑马程序员——C语言基础——冒泡排序算法探究

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

在整理前几天的C语言学习笔记的时候，看到了这个冒泡排序算法的问题 。

在复习这块内容试着编写一个函数时，我遇到了一些问题。让我们来看看我是怎么解决他们的。

1.首先来看一段标准的冒泡排序算法的代码：

#include <stdio.h>
void sort(int *a,int len){
int t;
for(int i = 0; i < len; i++){
for(int j = 0; j < len - i - 1; j++){
if(a[j] > a[j + 1]){
t = a[j];
a[j] = a[j + 1];
a[j + 1] = t;
}
}
}
}

运行后的有效步数为13次，此标准方法将相邻的数值两两交换，直到最后排序完成。

2.再来看看作为C语言初学者所编写的冒泡排序算法

void showArray(int *array, int len){
for (int i = 0, max = len; i < max; i++) {
printf("%d\t", array[i]);
}
}

int main(int argc, const char * argv[]) {
//定义数组
int array[] = {23, 56, 17, 24, 89, 10, 16, 57, 88, 84};
int t = 0;
//循环数组，每次取出一个值进行循环
for (int i = 0, max = 10; i < max; i++) {
for (int j = 0, max = 10; j < max; j++) {
if( array[i] < array[j]){
t = array[j];
array[j] = array[i];
array[i] = t;
showArray(array, 10);
printf("\n");
}
}
}

for (int i = 0, max = sizeof(array) / sizeof(array[0]); i < max; i++) {
printf("%d\t", array[i]);
}
}

上面提到比较标准的冒泡排序算法大概用了17步处理，来完成排序。

而这段方法则执行了22步处理，效率几乎下降了30%！是什么原因造成了这个现象？

通过分析发现第一种方法只在排序中，完成了那些必要的数值交换操作。

而第二种方法的数值交换记录如下：

56	23	17	24	89	10	16	57	88	84
89	23	17	24	56	10	16	57	88	84
23	89	17	24	56	10	16	57	88	84
17	89	23	24	56	10	16	57	88	84
17	23	89	24	56	10	16	57	88	84
17	23	24	89	56	10	16	57	88	84
17	23	24	56	89	10	16	57	88	84
10	23	24	56	89	17	16	57	88	84
10	17	24	56	89	23	16	57	88	84
10	17	23	56	89	24	16	57	88	84
10	17	23	24	89	56	16	57	88	84
10	17	23	24	56	89	16	57	88	84
10	16	23	24	56	89	17	57	88	84
10	16	17	24	56	89	23	57	88	84
10	16	17	23	56	89	24	57	88	84
10	16	17	23	24	89	56	57	88	84
10	16	17	23	24	56	89	57	88	84
10	16	17	23	24	56	57	89	88	84
10	16	17	23	24	56	57	88	89	84
10	16	17	23	24	56	57	84	89	88
10	16	17	23	24	56	57	84	88	89
10	16	17	23	24	56	57	84	88	89

通过记录可以发现由于初始数据的顺序中，有个别较大数字位于数组前几项。

而这种算法由于每次都会与自身比较、与数值交换后的数组项进行比较。

由此导致了算法的冗余。并且这种冗余还会随着数据随机性而不断加大。

可见，算法的重要性无处不在。一个完善的算法不仅会使代码量减少，代码逻辑清晰。

更可能会减小内存消耗，提升运行速度。甚至会改善我们APP的用户体验。