冒泡排序代码

最简单的排序方法是冒泡排序方法。这种方法的基本思想是，将待排序的元素看作是竖着排列的“气泡”，较小的元素比较轻，从而要往上浮。在冒泡排序算法中我们要对这个“气泡”序列处理若干遍。所谓一遍处理，就是自底向上检查一遍这个序列，并时刻注意两个相邻的元素的顺序是否正确。如果发现两个相邻元素的顺序不对，即“轻”的元素在下面，就交换它们的位置。显然，处理一遍之后，“最轻”的元素就浮到了最高位置；处理二遍之后，“次轻”的元素就浮到了次高位置。在作第二遍处理时，由于最高位置上的元素已是“最轻”元素，所以不必检查。一般地，第i遍处理时，不必检查第i高位置以上的元素，因为经过前面i-1遍的处理，它们已正确地排好序。这个算法可实现如下。

void  BasicBubbleSort( int  a[],  int  n)
{
     if (a == NULL)
         return ;

     for ( int  i = n - 2 ; i >= 0 ;  -- i)
         for ( int  j = 0 ; j <= i;  ++ j)
             if (a[j + 1 ] < a[j])
            {
                 int  t  =  a[j + 1 ];
                a[j + 1 ]  =  a[j];
                a[j]  =  t;
            }

}

 

可以对冒泡算法作一些改进，如果算法第二行的某次内循环没有进行元素交换，则说明排序工作已经完成，可以退出外循环。可以用一个布尔变量来记录内循环是否进行了记录交换，如果没有则终止外循环。 代码如下：

void  EnchancedBubbleSort( int  a[],  int  n)
{
     if (a == NULL)
         return ;

     for ( int  i = n - 2 ; i >= 0 ;  -- i)
    {
        bool flag  =   true ;
         for ( int  j = 0 ; j <= i;  ++ j)
             if (a[j + 1 ] < a[j])
            {
                 int  t  =  a[j + 1 ];
                a[j + 1 ]  =  a[j];
                a[j]  =  t;
                flag  =   false ;
            }
         if (flag)
             break ;
    }
}

 

冒泡法的另一个改进版本是双向扫描冒泡法，来回地进行扫描，即先从头扫到尾，再从尾扫到头，直到排好序，代码如下：

void  BinBubbleSort( int  a[],  int  start,  int  end)
{
     if (a == NULL)
         return ;

     while (start < end)
    {
         int  tend  =  end;
        end  =  start;
         for ( int  i = start; i < tend;  ++ i)
             if (a[i] > a[i + 1 ])
            {
                 int  t  =  a[i + 1 ];
                a[i + 1 ]  =  a[i];
                a[i]  =  t;
                end  =  i;
            }

         int  tstart  =  start;
        start  =  end;
         for ( int  j = end; j > tstart;  -- j)
             if (a[j] < a[j - 1 ])
            {
                 int  t  =  a[j];
                a[j]  =  a[j - 1 ];
                a[j - 1 ]  =  t;
                start  =  j;
            }

    }
}