排序-冒泡排序

交换排序：如果发生逆序则交换，直到所有记录都排好序为止。

最简单的交换排序就是人们所熟知的冒泡排序了。这也是我最早接触的排序算法了。

冒泡排序的思想：每一趟排序时，从首记录开始相邻两树进行比较，逆序则交换，每趟排序都会使当前最大的数沉到末尾。小数逐步上升，至多n-1趟排序完成，若中间某趟无交换则排序完成。

输入：顺序表的长度，顺序表中各个元素。

输出：排好序的顺序表中各个元素。

运行结果：

辅助宏：

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -1
#define NULL 0
typedef char *InfoType;
typedef int KeyType; //设关键字为整型

顺序表的存储结构定义：

typedef struct
{
   KeyType key; //关键字
   InfoType otherinfo;//其他数据项
}RedType;
//顺序表的存储结构定义
typedef struct
{
   RedType *r; //r[0]一般做哨兵
   int length; //顺序表的长度
}SqList;

算法实现：

void BubbleSort(SqList &L)
{
    /*冒泡排序
    每一趟排序时，从首记录开始相邻两数进行比较，逆序则
    交换，每趟排序都会使当前最大的数沉到末尾，小数逐步
    上升，至多n-1趟排序完成，若中间某趟无交换则排序完成*/
    int i,j,isOrder; //isOrder判断是否已经排好序
    RedType t;
    for(i=1;i<=L.length-1;i++)
    {
        isOrder=TRUE;
        for(j=1;j<=L.length-i;j++)
	    if(L.r[j].key>L.r[j+1].key)
            {
	        isOrder=FALSE;  //有交换说明没有排好序
		RedCopy(t,L.r[j]);
                RedCopy(L.r[j],L.r[j+1]);
		RedCopy(L.r[j+1],t);
	    }
     if(isOrder)   //如果排好序之间返回
         return;
   }
}

复制元素r2到r1

void RedCopy(RedType &r1,RedType r2)
{
    //复制元素r2到r1
    r1.key=r2.key;
    r1.otherinfo=r2.otherinfo;
}

算法分析：

最好情况下，只需一趟排序，比较次数为n-1，不移动。

最坏情况下n-1趟排序，第i趟比较n-i次，移动3（n-i）次。

计算得总的比较次数 n*(n-1)/2 移动次数 3n*(n-1)/2

时间复杂度O(n^2)

空间复杂度O(1)

是一种稳定的排序算法。