排序——冒泡（起泡）排序

冒泡排序的基本思想：

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

3. 针对所有的元素重复以上的步骤，除了最后一个。

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

案例：

代码：

最普通的冒泡排序算法：

#include<stdio.h> 

void bubble_sort(int arr[], int len) {  
    int i, j;  
    for (i = 0; i < len - 1; i++) {
	 
        for (j = 0; j < len - 1 - i; j++) {
		 
            if (arr[j] > arr[j + 1]) {
			 
               // swap(arr[j], arr[j + 1]);  
               int temp = arr[j];
               arr[j] = arr[j+1];
               arr[j+1] = temp;
            }
	} 
	printf("\n第%d趟排序序列：\n", i);
	for (int i = 0; i < 7; i++) {
		printf("%d\t", arr[i]);
	}
	printf("\n");
    } 
}  

int main() {
//	int a[7] = {1, 2, 3, 4, 5, 6, 7};
	int a[7] = {7, 4, 9, 5, 1, 3, 2};
	bubble_sort(a, 7);
//	bubble_sort_good(a, 7);
	printf("\n最终排序结果\n");
	for (int i = 0; i < 7; i++) {
		printf("%d\t", a[i]);
	}
	printf("\n");
	
}

运行结果：

第0趟排序序列：
4       7       5       1       3       2       9

第1趟排序序列：
4       5       1       3       2       7       9

第2趟排序序列：
4       1       3       2       5       7       9

第3趟排序序列：
1       3       2       4       5       7       9

第4趟排序序列：
1       2       3       4       5       7       9

第5趟排序序列：
1       2       3       4       5       7       9

最终排序结果
1       2       3       4       5       7       9

分析：

 

改进的冒泡排序算法：

#include<stdio.h> 
/*算法改进和变种
设置标志变量change
标志变量用于记录每趟冒泡排序是否发生数据元素位置交换。如果没有发生交换，说明序列已经有序了，不必继续进行下去了。
[cpp] view plain copy*/ 
//change = 1 表示没有交换，change = 0 表示已经交换过，则在后续中不需要再进行交换了 
void bubble_sort_good(int arr[], int len) {  

    int i, j, change=1;  
          
    for (i = 0; i < len - 1 && change!=0; i++) {  
    
        change=0;  
        
        for (j = 0; j < len - 1 - i; j++) {
		 
            if (arr[j] > arr[j + 1]) {  
            
               // swap(arr[j], arr[j + 1]); 
			   int temp = arr[j];
               arr[j] = arr[j+1];
               arr[j+1] = temp; 
                //如果这两个数已经交换了，则change标记为1，则在后续不需要再进行交换了 
                change = 1;  
            }  
        } 
        
        printf("\n第%d趟排序序列：\n", i);
		for (int i = 0; i < 7; i++) {
			printf("%d\t", arr[i]);
		}
		printf("\n");
	} 
} 

int main() {
	int a[7] = {1, 2, 3, 4, 5, 6, 7};
//	bubble_sort(a, 7);
	bubble_sort_good(a, 7);
	printf("\n最终排序结果\n");
	for (int i = 0; i < 7; i++) {
		printf("%d\t", a[i]);
	}
	printf("\n");
	
}

两种算法的比较：

普通的冒泡排序算法运行结果：

第0趟排序序列：
1       2       3       4       5       6       7

第1趟排序序列：
1       2       3       4       5       6       7

第2趟排序序列：
1       2       3       4       5       6       7

第3趟排序序列：
1       2       3       4       5       6       7

第4趟排序序列：
1       2       3       4       5       6       7

第5趟排序序列：
1       2       3       4       5       6       7

最终排序结果
1       2       3       4       5       6       7

--------------------------------

改进的冒泡排序算法运行结果：

第0趟排序序列：
1       2       3       4       5       6       7

最终排序结果
1       2       3       4       5       6       7

--------------------------------

通过两种算法的运行结果可以看出，改进的算法效率明显更高。