冒泡排序

冒泡算法代码实现

打印程序
int display(int *arr)
{
    int i;

    for(i = 0; i < N; i++)
    {
        printf("%d  ", arr[i]);
    }
    putchar(10);

    return 0;
}

冒泡排序程序
int main(int argc, const char *argv[])
{
    int i, j, mid;
    int arr[N] = {10, 1, 9, 2, 8, 3, 7, 4, 6, 5};

    puts("初始状态：");
    display(arr);
    putchar(10);

    //第一个for循环中的i，表示要比较的元素下标范围，即0 <= i <= (N-1),等同于0 <= i <= 8；
    //N-1表示要比较的轮次，即10-1=9轮；
    for(i = 0; i < N-1; i++)
    {

        //第二个for循环中的j，表示每轮被比较的元素下标范围，
        //第1轮，1-9;第2轮，2-9；第3轮，3-9；...第9轮，8-9；
        for(j = i+1; j < N; j++)
        {
            if(arr[i] > arr[j])
            {
                mid    = arr[i];
                arr[i] = arr[j];
                arr[j] = mid;
            }
        }
        printf("第%d轮后：",i+1);
        display(arr);
    }

    return 0;
}

打印结果：
初始状态：
10  1  9  2  8  3  7  4  6  5  

第1轮后：1  10  9  2  8  3  7  4  6  5  
第2轮后：1  2  10  9  8  3  7  4  6  5  
第3轮后：1  2  3  10  9  8  7  4  6  5  
第4轮后：1  2  3  4  10  9  8  7  6  5  
第5轮后：1  2  3  4  5  10  9  8  7  6  
第6轮后：1  2  3  4  5  6  10  9  8  7  
第7轮后：1  2  3  4  5  6  7  10  9  8  
第8轮后：1  2  3  4  5  6  7  8  10  9  
第9轮后：1  2  3  4  5  6  7  8  9  10  

冒泡算法实现原理

中心思想：按照指定顺序（增序或降序）每轮取一个基准值与其后边的元素进行比较，同时每轮确认出一个最大（降序）或最小（增序）的元素，排列在最前面；
就像冒泡一样，每轮冒出一个想要的泡泡来。。
（现在是升序，第一轮冒出1，第二轮冒出2，第三轮冒出3，…，第九轮冒出9，剩下10就是最后一个元素）

初始状态：10 1 9 2 8 3 7 4 6 5

1. 第一轮：

将基准值（a[0],即10）与数组中其他元素进行比较，如果基准值大于被比较元素，则交换两个元素位置；
10 与 1 比较，10 > 1，故交换；

则此时数组状态为：
1 10 9 2 8 3 7 4 6 5

交换后基准值变成了1（即a[0]=1），此时在将基准值与9（j++）进行比较,显然1<9,不交换。再次与2比较（j++）,与此类推，将1与后边各个元素进行比较。显然，1现在是最小的值。故第一轮比较交换完毕后，数组状态为：
1 10 9 2 8 3 7 4 6 5

2.第二轮

将第二个元素10作为基准值，与其后面所有元素进行比较，找出一个最小值放到第二个元素的位置；

（a、10与9比，10大于9，两个元素交换位置：1 9 10 2 8 3 7 4 6 5；
b、9与2比，9大于2，两个元素交换位置：1 2 10 9 8 3 7 4 6 5；
c、2分别与8/3/7/4/6/5进行比较，2均小于后边的元素，所以不交换位置）

第二轮交换完毕后状态为：
1 2 10 9 8 3 7 4 6 5

第三轮至第九轮，均以此方式进行。