005.交换排序—冒泡排序（Bubble Sort）

//=========================以下为自己实现=============================

#include <stdlib.h>
#include <stdio.h>


#define  aray_num 10


void printfArray(int list[])
{
    int i;
    for(i=0; i<aray_num-1; i++)
    {
        printf("%d, ", list[i]);
    }
    printf("%d\n", list[aray_num-1]);
}


void bubbleSort(int a[], int n)
{  
    int i,temp;
    int left=0;
    int right=n-1;
    while(left < right)
    {
        for(i=left; i<right; ++i)
        {
            if(a[i] > a[i+1])
            {
                temp=a[i];
                a[i]=a[i+1];
                a[i+1]=temp;
            }
        }
        right--;
        
        for(i=right; i>left; --i)
        {
            if(a[i-1] > a[i])
            {
                temp=a[i-1];
                a[i-1]=a[i];
                a[i]=temp;
            }
        } 
        left++;
    }
}  


void bubbleSort1(int a[], int n)
{  
    int i,j,temp;
    for(i=0; i<n; i++)
    {
        for(j=0; j<n-i-1; ++j)
        {
            if(a[j] > a[j+1])
            {
                temp=a[j+1];
                a[j+1]=a[j];
                a[j]=temp;
            }
        }
    }
}  
int main(int argc, char **argv)
{
    //初始化一个序列
    int aray1[aray_num] = {50, 123, 543, 187, 49, 30, 0, 2, 11, 100};
    
    printf("before sort, the data is :");
    printfArray(aray1);


    //调用冒泡排序方法
    bubbleSort(aray1, aray_num);


    printf("after sort, the data is :");
    printfArray(aray1);


    system("pause"); 
    return 0;
}

//=========================以下为转载==============================

基本思想：

在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

冒泡排序的示例：

 

算法的实现：

1. void bubbleSort(int a[], int n){  
2.     for(int i =0 ; i< n-1; ++i) {  
3.         for(int j = 0; j < n-i-1; ++j) {  
4.             if(a[j] > a[j+1])  
5.             {  
6.                 int tmp = a[j] ; a[j] = a[j+1] ;  a[j+1] = tmp;  
7.             }  
8.         }  
9.     }  
10. }  

11. 冒泡排序算法的改进

    对冒泡排序常见的改进方法是加入一标志性变量exchange，用于标志某一趟排序过程中是否有数据交换，如果进行某一趟排序时并没有进行数据交换，则说明数据已经按要求排列好，可立即结束排序，避免不必要的比较过程。本文再提供以下两种改进算法：

    1．设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。

    改进后算法如下:

1. void Bubble_1 ( int r[], int n) {  
2.     int i= n -1;  //初始时,最后位置保持不变  
3.     while ( i> 0) {   
4.         int pos= 0; //每趟开始时,无记录交换  
5.         for (int j= 0; j< i; j++)  
6.             if (r[j]> r[j+1]) {  
7.                 pos= j; //记录交换的位置   
8.                 int tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;  
9.             }   
10.         i= pos; //为下一趟排序作准备  
11.      }   
12. }    

2．传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。

改进后的算法实现为:

1. void Bubble_2 ( int r[], int n){  
2.     int low = 0;   
3.     int high= n -1; //设置变量的初始值  
4.     int tmp,j;  
5.     while (low < high) {  
6.         for (j= low; j< high; ++j) //正向冒泡,找到最大者  
7.             if (r[j]> r[j+1]) {  
8.                 tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;  
9.             }   
10.         --high;                 //修改high值, 前移一位  
11.         for ( j=high; j>low; --j) //反向冒泡,找到最小者  
12.             if (r[j]<r[j-1]) {  
13.                 tmp = r[j]; r[j]=r[j-1];r[j-1]=tmp;  
14.             }  
15.         ++low;                  //修改low值,后移一位  
16.     }   
17. }