冒泡排序

对《大话数据结构》P378~P383—冒泡排序，进行了自己的理解并完善了代码。

三种冒泡排序如下：

1、冒泡排序初级版

代码和解释如下（VS2012测试通过）：

#include <iostream>
using namespace std;
#define MAXSIZE 5//用于要排序数组个数最大值，可根据需要修改

//排序用的顺序表结构
typedef struct
{
    int r[MAXSIZE+1];//定义一个数组，用于存储要排序的数，r[0]作为临时变量
    int length;//用于记录顺序表的长度
}SqList;

//排序表的初始化
SqList *InitSqList(SqList *L)
{
    L=new SqList;
    L->length=5;//本例中长度是5
    cout<<"input list"<<endl;
    for(int i=1;i<=L->length;i++)
        cin>>L->r[i];
    return L;
}

//数组遍历输出
void PrintSqList(SqList *L)
{
    for(int i=1;i<=L->length;i++)
        cout<<L->r[i]<<" ";
    cout<<endl;
}


//交换r[i]和r[j]
void swap(SqList *L,int i,int j)
{
    int temp=L->r[i];
    L->r[i]=L->r[j];
    L->r[j]=temp;
}

//冒泡排序初级版
void BubbleSort0(SqList *L)
{
    for(int i=1;i<L->length;i++)
    {
        for(int j=i+1;j<=L->length;j++)
        {
            if(L->r[i]>L->r[j])
                swap(L,i,j);//交换顺序表中下标i和j的元素
        }
        cout<<"after one sort"<<endl;
        PrintSqList(L);
    }
}

int main()
{
    SqList *p=NULL;
    p=InitSqList(p);//初始化
    BubbleSort0(p);//排序
    cout<<"after sort"<<endl;
    PrintSqList(p);//输出
}

运行结果：

2、冒泡排序正宗版

代码和解释如下（VS2012测试通过）：

#include <iostream>
using namespace std;
#define MAXSIZE 5//用于要排序数组个数最大值，可根据需要修改

//排序用的顺序表结构
typedef struct
{
    int r[MAXSIZE+1];//定义一个数组，用于存储要排序的数，r[0]作为临时变量
    int length;//用于记录顺序表的长度
}SqList;

//排序表的初始化
SqList *InitSqList(SqList *L)
{
    L=new SqList;
    L->length=5;//本例中长度是5
    cout<<"input list"<<endl;
    for(int i=1;i<=L->length;i++)
        cin>>L->r[i];
    return L;
}

//数组遍历输出
void PrintSqList(SqList *L)
{
    for(int i=1;i<=L->length;i++)
        cout<<L->r[i]<<" ";
    cout<<endl;
}


//交换r[i]和r[j]
void swap(SqList *L,int i,int j)
{
    int temp=L->r[i];
    L->r[i]=L->r[j];
    L->r[j]=temp;
}

//冒泡排序正宗版
void BubbleSort(SqList *L)
{
    for(int i=1;i<L->length;i++)
    {
        for(int j=L->length-1;j>=i;j--)
        {
            if(L->r[j]>L->r[j+1])
                swap(L,j,j+1);//交换顺序表中下标i和j的元素
        }
        cout<<"after one sort"<<endl;
        PrintSqList(L);
    }
}

int main()
{
    SqList *p=NULL;
    p=InitSqList(p);//初始化
    BubbleSort(p);//排序
    cout<<"after sort"<<endl;
    PrintSqList(p);//输出
}

运行结果：

3、冒泡排序优化版

代码和解释如下（VS2012测试通过）：

#include <iostream>
using namespace std;
#define MAXSIZE 5//用于要排序数组个数最大值，可根据需要修改

//排序用的顺序表结构
typedef struct
{
    int r[MAXSIZE+1];//定义一个数组，用于存储要排序的数，r[0]作为临时变量
    int length;//用于记录顺序表的长度
}SqList;

//排序表的初始化
SqList *InitSqList(SqList *L)
{
    L=new SqList;
    L->length=5;//本例中长度是5
    cout<<"input list"<<endl;
    for(int i=1;i<=L->length;i++)
        cin>>L->r[i];
    return L;
}

//数组遍历输出
void PrintSqList(SqList *L)
{
    for(int i=1;i<=L->length;i++)
        cout<<L->r[i]<<" ";
    cout<<endl;
}


//交换r[i]和r[j]
void swap(SqList *L,int i,int j)
{
    int temp=L->r[i];
    L->r[i]=L->r[j];
    L->r[j]=temp;
}

//冒泡排序优化
void BubbleSort(SqList *L)
{
    int flag=1;//定义一个标志位，如果没有任何数据交换了，说明已经排好序，不用再循环
    for(int i=1;(i<L->length)&&(flag==1);i++)
    {
        flag=0;//进行一次i循环之前，把flag置0，确保下一次循环是必要的
        for(int j=L->length-1;j>=i;j--)
        {
            if(L->r[j]>L->r[j+1])
            {
                swap(L,j,j+1);//交换顺序表中下标i和j的元素
                flag=1;//表示刚才有数据交换，所以实际上仍然有一次i的for循环是浪费的(看运行结果就知道了)
            }
        }
        cout<<"after one sort"<<endl;
        PrintSqList(L);
    }
}

int main()
{
    SqList *p=NULL;
    p=InitSqList(p);//初始化
    BubbleSort(p);//排序
    cout<<"after sort"<<endl;
    PrintSqList(p);//输出
}

运行结果：

 

对于第三种冒泡排序优化版，时间复杂度的分析只对两种极端情况考虑：

1、排序表本身就是有序的。只需要两两比较一次确认是有序的即可。即n-1次比较，没有数据交换。时间复杂度是O(n)。

2、排序表正好是逆序的。

第1次从最后一个到第一个，进行n-1次比较，两两交换。第1个归位。

第2次从最后一个到第二个，进行n-2次比较，两两交换。第2个归位。

...

第n-2次从最后一个到n-2个，进行2次比较，两两交换。n-2个归位。

第n-1次从最后一个到n-1个，进行1次比较，两两交换。n-1个归位。

结束。

需要比较n-1+n-2+...+2+1=n(n-1)/2次，并做等数量级的交换。因此时间复杂度是O(n²)。