复习排序-冒泡排序

冒泡排序

两两交换，遍历整个数组，将最大值（最小值）提取到数组的底部（顶部）。算法时间复杂度为O(n^2)

算法实现一:两层循环，第一层循环减少每次遍历的元素个数，第二层循环通过两两比较、交换实现最小值沉入底部。

void BubbeSort(int *num, int length){  inti,j;  for(i=0;i<length-1;i++)    for(j=0;j<length-i-1;j++)      {         if(num[j]>num[j+1])           swap(&num[j],&num[j+1]);      }}

执行过程：

6 3 8 5 7 1 0 4 2    最初的数组

3 6 5 7 1 0 4 2 8    第一轮

3 5 6 1 0 4 2 7 8    第二轮

3 5 1 0 4 2 6 7 8    第三轮

3 1 0 4 2 5 6 7 8    第四轮

1 0 3 2 4 5 6 7 8    第五轮

0 1 2 3 4 5 6 7 8    第六轮

0 1 2 3 4 5 6 7 8    第七轮（多余执行）

0 1 2 3 4 5 6 7 8    第八轮（多余执行）

 

对冒泡排序的优化：在排序已经完成时，停止余下的扫描轮数，通过添加标志位来实现。

void BubbeSort(int *num, int length){    int i,j;    bool flag = true;    for(i=0;i<length-1&& flag ;i++)    {        flag = false;        for(j=0;j<length-i-1;j++)        {             if(num[j]>num[j+1])             {                 swap(&num[j],&num[j+1]);                 flag= true;             }         }    }}

执行结果：

6 3 8 5 7 1 0 4 2    最初数组元素

3 6 5 7 1 0 4 2 8

3 5 6 1 0 4 2 7 8

3 5 1 0 4 2 6 7 8

3 1 0 4 2 5 6 7 8

1 0 3 2 4 5 6 7 8

0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8    （多余一行）