排序算法（4）——冒泡排序

冒泡排序（Bubble Sort）

1.传统的冒泡排序算法

       （1）算法思想

         当进行升序的冒泡排序时，则从后往前，依次比较相邻的两个数，若前面的数大于后面的数，则进行交换。第一次循环结束后，待排序序列A[1..n]中的最小元素被交换到A[1]位置。经过n-1次循环，即可完成对A的排序。

         若对A=（49,  38, 65,  97,  76,  13,  27,  49）进行冒泡排序，第1次循环元素的交换过程过程如下所示（双向箭头：交换）：

         冒泡排序的整个过程如下图所示：

       （2）伪代码

          BUBBLE-SORT(A)

          1   for i ← 1 to length[A] - 1

          2        do for j ← downto i + 1

          3                  do if  A[j]<A[j-1]

          4                           then exchange A[j] ↔ A[j-1]

       （3）代码实现

void BubbleSort_1(int A[],int n)
{
    int i,j;
    for(i=0;i<n;i++)
    {
        for(j=n-1;j>=i+1;j--)
        {
            if(A[j]<A[j-1])
            {
                int temp=A[j];
                A[j]=A[j-1];
                A[j-1]=temp;
            }
        }
    }
}

       （4）算法分析

         a.冒泡的时间复杂度为：Θ（n^2）。

         b.冒泡排序是一种原地排序。

         c.冒泡排序是一种稳定排序。

2.冒泡算法的改进

        （1）改进（一）：设置交换标识

         从上面图示的例子可以看出，当第4次循环结束后，数组A就已经是有序的了，后面的循环不再进行交换操作，但是传统的冒泡排序仍然进行后面的循环。这里可以设置一个交换标识（change_flag），当一次循环中没有发生任何交换操作，则停止后面的循环，这样能减少循环的次数。改进后的实现如下：

void BubbleSort_2(int A[],int n)
{
    int i,j;
    bool change_flag=true;
    for(i=0;i<n&&change_flag;i++)       //只有当上次循环中有交换发生，才继续进行本次的循环
    {
        change_flag=false;              //每次循环开始时，设置change_flag为false
        for(j=n-1;j>=i+1;j--)
        {
            if(A[j]<A[j-1])
            {
                int temp=A[j];
                A[j]=A[j-1];
                A[j-1]=temp;
                change_flag=true;        //有交换进行，change_flag设置为true
            }
        }
    }
}

           （2）改进（二）：双向冒泡排序

            双向冒泡排序即在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。具体实现如下：

void BubbleSort_3(int A[],int n)
{
    int low=0;
    int high=n-1;
    while(low<high)
    {
        int j;
        for(j=low;j<high;j++)   //正向冒泡，找最大值
        {
            if(A[j]>A[j+1])
            {
                int temp=A[j];
                A[j]=A[j+1];
                A[j+1]=temp;
            }
        }
        high--;
        for(j=high;j>low;j--)  //反向冒泡，找最小值
        {
            if(A[j]<A[j-1])
            {
                int temp=A[j];
                A[j]=A[j-1];
                A[j-1]=temp;
            }
        }
        low++;
    }
}