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

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

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

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

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

#include 
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的用户体验。