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

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

---

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。

1. 基本思想

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

2. 排序流程

冒泡排序算法的运作如下：（从后往前）
（1）比较相邻的元素。如果第一个比第二个大，就交换他们两个。
（2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
（3）针对所有的元素重复以上的步骤，除了最后一个。
（4）持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

3. 算法实现

3.1 基本冒泡排序

代码

#include <stdio.h>

#define N 9

#ifdef RAND
int arr[N]={
  6,3,9,7,2,4,5,1,8};
#elif defined(INVERT)
int arr[N]={
  9,8,7,6,5,4,3,2,1};
#elif defined(ORDER)
int arr[N]={
  1,2,3,4,5,6,7,8,9};
#else
int arr[N]={
  9,5,2,8,6,4,3,1,7};
#endif

int step=0;

/* 打印数组 */
void print(int array[])
{
    int i;
    printf("No.%d\t",step++);
    for(i=0;i<N;i++)
        printf("%d ",array[i]);
    printf("\n");
}

/* 冒泡排序：循环实现 */
void bubble_sort_for(int array[],int n)
{
    int i, j, temp;
    for (j = 0; j < n - 1; j++)
    {
        for (i = 0; i < n - 1 - j; i++)
        {
            if(array[i] > array[i + 1]) /* 一次判断相邻元素大小，大于则交换 */
            {
                temp = array[i];
                array[i] = array[i + 1];
                array[i + 1] = temp;
            }
        }
        print(array);
    }
}

/* 冒泡排序：递归实现 */
void bubble_sort_recursion(int array[],int n)
{
    int i, temp;

    /* 一个数无需排序 */
    if(n<2) return;

    for (i = 0; i < n - 1; i++)
    {
        if(array[i] > array[i + 1]) /* 一次判断相邻元素大小，大于则交换 */
        {
            /* 大于则交换，将大数放到最后 */
            temp = array[i];
            array[i] = array[i + 1];
            array[i + 1] = temp;
        }
     }

    print(arr);
    bubble_sort_recursion(array,n-1);
}

void main()
{
    printf("Before...\n");
    print(arr);
    printf("Sorting...\n");
    //bubble_sort_for(arr,N);
    bubble_sort_recursion(arr,N);
    printf("Sorted.\n");
}

结果

Before...
No.0    9 5 2 8 6 4 3 1 7 
Sorting...
No.1    5 2 8 6 4 3 1 7 9 
No.2    2 5 6 4 3 1 7 8 9 
No.3    2 5 4 3 1 6 7 8 9 
No.4    2 4 3 1 5 6 7 8 9 
No.5    2 3 1 4 5 6 7 8 9 
No.6    2 1 3 4 5 6 7 8 9 
No.7    1 2 3 4 5 6 7 8 9 
No.8    1 2 3 4 5 6 7 8 9 
Sorted.

3.2 第一种改进：有序则停

如果在某一趟循环中没有任何数据交换发生，则表明数据已经排序完毕。那么剩余的循环就不需要再执行了。

代码

void bubble_sort(int array[],int n)
{
    int i, j, temp;
    for (j = 0; j < n - 1 && (!isSorted); j++) /* 每一趟排序都判断是否已经有序，有序则停 */
    {
        step++;
        isSorted=TRUE;
        for (i = 0; i < n - 1 - j; i++)
        {
            if(array[i] > array[i + 1]) /* 一次判断相邻元素大小，大于则交换 */
            {
                isSorted=FALSE;
                temp = array[i];
                array[i] = array[i + 1];
                array[i + 1] = temp;
            }
        }
        print(array);
    }
}

结果

Before...
No.0    1 2 3 4 5 7 6 8 9   isSorted:0
Sorting...
No.1    1 2 3 4 5 6 7 8 9   isSorted:0
No.2    1 2 3 4 5 6 7 8 9   isSorted:1
Sorted.

3.3 第二种改进：有序记录

在冒泡排序的每趟扫描中，记住最后一次交换发生的位置。因为该位置之后的相邻元素已经有序，故下一趟排序开始的时候，只需扫描该位置之前的元素。所以一趟排序可能使当前有序区扩充多个记录，即最大程度的缩小无序区范围，而非递减1，以此减少排序趟数。

代码

void bubble_sort(int array[],int n)
{
    int i, j, temp;
    int lastExchange = n-1,pos;

    while(lastExchange>1) /* 最后交换位置终止条件 */
    {
        step++;
        pos=0;
        for (i = 0; i < lastExchange; i++)
        {
            if(array[i] > array[i + 1]) /* 一次判断相邻元素大小，大于则交换 */
            {
                pos=i; /* 记录每次交换位置 */
                temp = array[i];
                array[i] = array[i + 1];
                array[i + 1] = temp;
            }
        }
        lastExchange=pos;