排序算法——冒泡排序

1.冒泡排序算法的原理如下：

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

2.程序实现：

void BubbleSort(int a[],int n)
{ 
    int temp=0;
    for(int i=0;i<n-1;i++)
    {
        for(int j=0;j<n-i-1;j++)
        {
            if(a[j]>a[j+1])
            {
                //修改顺序
                temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
            }
        }
    }
    
 }

3.时间复杂度分析：

算法中基本操作是比较。

（1）最好情况：数组本来就是有序的，此时仍然需要比较n-1次，所以此时时间复杂度为O(n)。
（2）最差情况：数组反序，则要进行 n - 1 次遍历，第 i 次遍历时需要进行 n - i - 1 次基本操作（比较），因此总的基本操作次数为 n(n-1)/2，此时时间复杂度为O(n^2)。
（3）在上述代码实现中，即使数组是有序的，也需要进行n(n-1)/2次基本操作，时间复杂度为O(n^2)。

4.算法改进

由于上述算法实现中，即使数组本来就是有序的，也需要进行n(n-1)/2次比较，但其实如果在某次遍历中，没有进行交换操作，就证明数组已经实现有序了，可以结束循环了。

为此，可以设置一个bool型变量flag，来标志某次循环是否有元素交换。

void BubbleSort(int a[],int n)
{
    int temp=0;
    bool flag=flase;
    for(int i=0;i<n-1;i++)
    {
       if(i==0||flag==true)
       {
           flag=false;
           for(int j=0;j<n-i-1;j++)
           {
               if(a[j]>a[j+1])
               {
                   temp=a[j];
                   a[j]=a[j+1];
                   a[j+1]=temp;
                   flag=true;
                   //flag为true表示进行了交换操作
               }
           }
       }
       else
       {
           cout<<"进行了"<<i<<"次遍历"<<endl;
           break;//退出循环
       }
    }
 }

5.稳定性

冒泡排序是稳定的。
因为当a[j]=a[j+1]时是不需要将两个数交换的。