冒泡排序

开始学习排序算法，算是总结加记录吧。。

（1）主要思想：待排文件有n个记录，需要比较n-1次，每一次排序，依次比较最后两个记录的关键值的大小，若最后的记录关键值小于前一个记录关键值，将其交换，每一次排序后得到一个最小的记录位于文件的最前位置，经过n-1次，整个文件的记录就变成有序的。

（2）代码：

#include<stdio.h>

void Swap(int &m, int&n)

{

         int temp;

         temp= m;

         m= n;

         n =temp;

}

//正宗冒泡排序

void BubbleSort1(int a[], int len)

{

         int i, j,count =0;

         for (i=0; i<len; i++)

         {

                   for (j=len-1; j>i; j--)  //每一次循环，都是从数组最后两个元素相比

                            if (a[j] < a[j-1])

                                     Swap(a[j],a[j-1]);

                   //每循环完一次，都有一个最小的值排到最前边

         }

}

//改进冒泡排序

void BubbleSort(int a[], int len)

{

         int i , j, count=0;

         int flag = 1;

         for (i=0; i<len && flag == 1; i++)

         {

                   flag= 0;

                   for (j=len-1; j>i; j--)

                   {

                            if (a[j] < a[j-1])

                            {

                                     Swap(a[j],a[j-1]);         

                                flag = 1;

                            }

                            count++;

                   }

         }

         printf("%d\n",count);

}

void main()

{

         int a[] = {0,1,2,3,4,5,6,7,8,9};

         int len = 10;

         int i;

         for (i=0; i<len; i++)

                   printf("%d ",a[i]);

         printf("\n\n");

         BubbleSort1(a,len);

         for (i=0; i<len; i++)

                   printf("%d ",a[i]);

         printf("\n\n");

}

（3）算法分析：该算法时间复杂度主要表现在元素的比较次数，和记录的移动次数。

改进的冒泡排序时间复杂度:

最好情况下，待排序类已经有序，只需比较n次，即O(n),得到有序的文件。

最坏情况下，需要进行n-1次排序，每次排序进行3(n-i)次交换记录，此时复杂度为3n(n-1)/2=O(n^2)

平均时间复杂度，O(n^2)

空间复杂度 ：所需空间不依赖问题的规模大小n，为O(1),是就地排序。

（4）算法稳定性：稳定排序。