冒泡排序法

排序用到的结构与函数

# define MAXSIZE 10
 typedef struct {
     /* 用 于 存 储 要 排 序 数 组 ， r[0] 用 作 哨 兵 或 临 时 变 量 */
     int r[ MAXSIZE + 1];
     /* 用 于 记 录 顺 序 表 的 长 度 */
     int length ;
 } SqList ;
 /* 交 换 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 = 1; i < L- > length ; i++) {
     for (j = i + 1; j <= L- > length ; j++) {
         if (L- >r[i] > L->r[j]) {
             /* 交 换L- >r[i] 与L->r[j] 的 值 */
             swap (L, i, j) ;
             }
         }
     }
 }

冒泡排序经典版本——两两相比

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

冒泡排序升级版本

如果嵌入的内部循环不需要交换，那么说明后面这段序列初始值就是排好的

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