冒泡排序及其优化

#include<stdio.h>
#include<stdlib.h>
#include<ctime>
#define MAXSIZE 10
#define OK 1
#define TRUE 1
#define FLASE 0
typedef int Status;

 typedef struct
 {
     int r[MAXSIZE];  //用于存储要排序数组
     int length;     //用于记录顺序表的长度
 }SqList;


 Status initializer_list(SqList *L){
    L->length=0;
    return OK;
 }

 //i为插入位置，e为插入的值
 Status Insert_List(SqList *L,int i,int  e){
    int k;
    if(L->length==MAXSIZE)
        return FLASE;
    if(i<1||i>L->length+1)
        return FLASE;
    if(i<=L->length){ //插入位置不在尾部
        //需要把第i个位置的数据全部往后移动
        for(k=L->length;k>=i;k--)
            L->r[k]=L->r[k-1];
    }
    L->r[i-1]=e;
    L->length++;
    return OK;
 }

 Status visit(int s){
    printf("%d ",s);
    return OK;
 }

 //打印每个顺序表的元素
 Status List_Traverse(SqList L)
 {
    for(int i=0;i<L.length;i++)
        visit(L.r[i]);
        printf("\n");
        return OK;
 }

 Status List_length(SqList L)
 {
    return L.length;
 }


 //交换L中数组r的下标为i和j的值
 void swap(SqList *L,int i,int j)
 {
    int temp=L->r[i];
    L->r[i]=L->r[j];
    L->r[j]=temp;
 }

 //对顺序表L作交换排序(冒泡排序初级版)
 //每一个关键字都和后面的每一个关键字比较，如果大则交换
 //简单排序
 void BubbleSort0(SqList *L)
 {
    int i,j;
    for(i=0;i<L->length;i++){
        for(j=i+1;j<L->length;j++){
            if(L->r[i]>L->r[j]){
                swap(L,i,j);
            }
        }
    }
 }

 //两两比较相邻记录关键字，如果反序则交换
//经典冒泡
 void BubbleSort(SqList *L)
 {
     int i,j;
     for(i=0;i<L->length;i++){
        for(j=L->length-1;j>=i;j--){
            if(L->r[j-1]>L->r[j]){
                swap(L,j-1,j);
            }
        }
     }
 }

 //冒泡优化
 //增加一个标记值，当后面的数据不发生交换时证明此时的序列已经有序，不需要再进行排序了
 //如 1<3<5<7<9 已经有序，不需要交换，则不需要再进行循环
void BubbleSort2(SqList *L)
{
    int i,j;
    Status flag=TRUE; //使用flag用来做标记
    for(i=0;i<L->length && flag;i++){
        flag=FLASE;
         for(j=L->length-1;j>=i;j--){
             if(L->r[j-1]>L->r[j]){
                swap(L,j-1,j);
                flag=TRUE;
             }
         }
    }
}

int main(){
    int len,num;
    SqList L,Lb,Lc;
    initializer_list(&L);
    initializer_list(&Lb);
    initializer_list(&Lc);

    srand(time(0));
     for(int i=1;i<=10;i++)
     {
      //产生10以内的整数
        num=rand()%100+1;
        Insert_List(&L,1,num);
     }


    len=List_length(L);
    printf("线性表的长度为=%d\n",len);

    //查看线性表的元素
    printf("线性表中的数据是:");
    List_Traverse(L);

    BubbleSort0(&L);
    printf("线性表中的数据排序后是:");
    List_Traverse(L);

      for(int i=1;i<=10;i++)
     {
      //产生10以内的整数
        num=rand()%100+1;
        Insert_List(&Lb,1,num);
     }
    printf("线性表中的数据是:");
    List_Traverse(Lb);


    BubbleSort(&Lb);
    List_Traverse(Lb);


       for(int i=1;i<=10;i++)
     {
      //产生10以内的整数
        num=rand()%100+1;
        Insert_List(&Lc,1,num);
     }
    printf("线性表中的数据是:");
    List_Traverse(Lc);


    BubbleSort2(&Lc);
    List_Traverse(Lc);


}

冒泡排序复杂度分析

最好的情况，排序的表本身是有序的，那么我们比较次数，可以推断出就是n-1次比较，没有数据交换，时间复杂度为O(n)

最坏的情况，及待排序表示逆序的情况，此时我们需要比较1+2+3+4+5+6+7+8+9+.......+(n-1)=n*(n-1)/2次，并做等量数量级的记录移动，因此，总的时间复杂度为O(n^2)