冒泡排序算法思想及其优化

冒泡排序算法是把较小的元素往前调或者把较大的元素往后调。这种方法主要是通过对相邻两个元素进行大小的比较，根据比较结果和算法规则对该二元素的位置进行交换，这样逐个依次进行比较和交换，就能达到排序目的。冒泡排序的基本思想是，首先将第1个和第2个记录的关键字比较大小，如果是逆序的，就将这两个记录进行交换，再对第2个和第3个记录的关键字进行比较，依次类推，重复进行上述计算，直至完成第(n一1)个和第n个记录的关键字之间的比较，此后，再按照上述过程进行第2次、第3次排序，直至整个序列有序为止。排序过程中要特别注意的是，当相邻两个元素大小一致时，这一步操作就不需要交换位置，因此也说明冒泡排序是一种严格的稳定排序算法，它不改变序列中相同元素之间的相对位置关系。

冒泡排序的三种写法：
1）双层循环进行比较，外层循环控制比较趟数，内层循环控制比较交换次数，每趟结束后最大值都在末尾。
改进的思路是减少外层循环次数和内层循环的次数。推荐使用改版二，它2个次数都能修改。我最开始是这样写冒泡排序的，效率十分低。
缺点是某趟已经有序时，后面的次数还是会继续，外层循环次数总max，内层循环次数还是 max - i。

#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]的值 */
			}
		}
	}
}

2）改进1：
记录交换位置，可以省略下趟不必要的比较（如果后面几个元素已经是有序的，第二趟就直接不用比较这几个元素。

#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]的值 */
			}
		}
	}
}

3）改进2：
双向冒泡，正向找最大(从最小元素交换位置处开始比较，找到最大元素并记录交换位置)，反向找最小(从最大元素交换位置处开始比较，找到最小元素并记录交换位置).

#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 */
			}
		}
	}
}