冒泡排序是程序员最耳熟能详的排序了，本文简单叙述下我写过的三种冒泡排序写法。

冒泡，顾名思义，待排序的数字像气泡一样，通过比较，以升序或降序的方式排序。

我最开始是这样写冒泡排序的，效率十分低：

#include <stdio.h>

#define N 9
#define MAXSIZE 10000  /* 用于要排序数组个数最大值，可根据需要修改 */

typedef struct {
	int r[MAXSIZE+1];	/* 用于存储要排序数组，r[0]用作哨兵或临时变量 */
	int length;			/* 用于记录顺序表的长度 */
} SqList;


void swap(SqList *L, int i, int j);
void BubbleSort0(SqList *L);
void print(SqList L);
int main(void) {
	int i;
	int d[N]= {50,10,90,30,70,40,80,60,20};
	SqList list;

	for(i=0; i<N; i++)
		list.r[i+1]=d[i];
	list.length=N;
	printf("排序前:\n");
	print(list);

	printf("冒泡排序后:\n");
	BubbleSort0(&list);
	print(list);

	return 0;
}

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

void print(SqList L) {
	int i;
	for(i=1; i<L.length; i++)
		printf("%d,",L.r[i]);
	printf("%d",L.r[i]);
	printf("\n");
}

/* 对顺序表L作交换排序（冒泡排序初级版） */
void BubbleSort0(SqList *L) {
	int i, j;
	for(i = 1; i < L->length; i++) {
		for(j = i + 1; j <= L->length; j++) {
			if(L->r[i] > L->r[j]) {
				swap(L, i, j);/* 交换L->r[i]与L->r[j]的值 */
			}
		}
	}
}

后来有了点进步后：

#include <stdio.h>

#define N 9
#define MAXSIZE 10000  /* 用于要排序数组个数最大值，可根据需要修改 */

typedef struct {
	int r[MAXSIZE+1];	/* 用于存储要排序数组，r[0]用作哨兵或临时变量 */
	int length;			/* 用于记录顺序表的长度 */
} SqList;


void swap(SqList *L, int i, int j);
void BubbleSort0(SqList *L);
void print(SqList L);
int main(void) {
	int i;
	int d[N]= {50,10,90,30,70,40,80,60,20};
	SqList list;

	for(i=0; i<N; i++)
		list.r[i+1]=d[i];
	list.length=N;
	printf("排序前:\n");
	print(list);

	printf("冒泡排序后:\n");
	BubbleSort0(&list);
	print(list);

	return 0;
}

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

void print(SqList L) {
	int i;
	for(i=1; i<L.length; i++)
		printf("%d,",L.r[i]);
	printf("%d",L.r[i]);
	printf("\n");
}

/* 对顺序表L作交换排序（冒泡排序初级版） */
void BubbleSort0(SqList *L) {
	int i, j;
	for(i = 1; i < L->length; i++) {
		for(j = L->length - 1; j >= i; j--) { /* 注意j是从后往前循环 */
			if(L->r[j] > L->r[j+1]) { /* 若前者大于后者（注意这里与上一算法的差异）*/
				swap(L, j, j+1);/* 交换L->r[j]与L->r[j+1]的值 */
			}
		}
	}
}

看完《大话数据结构》后，又有新改进：

#include <stdio.h>

#define N 9
#define MAXSIZE 10000  /* 用于要排序数组个数最大值，可根据需要修改 */
#define TRUE 1
#define FALSE 0
typedef struct {
	int r[MAXSIZE+1];	/* 用于存储要排序数组，r[0]用作哨兵或临时变量 */
	int length;			/* 用于记录顺序表的长度 */
} SqList;

typedef int Status;
void swap(SqList *L, int i, int j);
void BubbleSort0(SqList *L);
void print(SqList L);
int main(void) {
	int i;
	int d[N]= {50,10,90,30,70,40,80,60,20};
	SqList list;

	for(i=0; i<N; i++)
		list.r[i+1]=d[i];
	list.length=N;
	printf("排序前:\n");
	print(list);

	printf("冒泡排序后:\n");
	BubbleSort0(&list);
	print(list);

	return 0;
}

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

void print(SqList L) {
	int i;
	for(i=1; i<L.length; i++)
		printf("%d,",L.r[i]);
	printf("%d",L.r[i]);
	printf("\n");
}

/* 对顺序表L作交换排序（冒泡排序初级版） */
void BubbleSort0(SqList *L) {
	int i, j;
	Status flag = TRUE;			/* flag用来作为标记 */
	for(i = 1; i < L->length && flag; i++) { /* 若flag为true说明有过数据交换，否则停止循环 */
		flag = FALSE;				/* 初始为False */
		for(j = L->length - 1; j >= i; j--) {
			if(L->r[j] > L->r[j+1]) {
				swap(L, j, j+1);	/* 交换L->r[j]与L->r[j+1]的值 */
				flag = TRUE;		/* 如果有数据交换，则flag为true */
			}
		}
	}
}