冒泡排序算法原理与 C 语言实现

一、原理

• 对一组数（假设为：5、1、4、3、2），利用冒泡排序，形成有序序列。
• 此处以排成从小到大的序列为例。

第 1 轮

• 从左往右，依次比较相邻的一对数。若左数大于右数，则两者交换；反之，不动。
• 第 1 轮，第 1 组:
  • 【比较】5 与 1
  • 【结果】1 ← 交换 → 5, 4, 3, 2
• 第 1 轮，第 2 组
  • 【比较】5 与 4
  • 【结果】4 ← 交换 → 5, 3, 2
• 第 1 轮，第 3 组
  • 【比较】5 与 3
  • 【结果】3 ← 交换 → 5, 2
• 第 1 轮，第 4 组
  • 【比较】5 与 2
  • 【结果】2 ← 交换 → 5
• 第 1 轮对 5 个数进行了 4 组比较，使最大的数位于序列的右端。

第 2 轮

• 对除最右端外剩余的 4 个数，进行第 2 轮比较。规则同前。
• 第 2 轮，第 1 组
  • 【比较】1 与 4
  • 【结果】1 不动，4, 3, 2, 5
• 第 2 轮，第 2 组
  • 【比较】4 与 3
  • 【结果】3 ← 交换 → 4, 2, 5
• 第 2 轮，第 3 组
  • 【比较】4 与 2
  • 【结果】2 ← 交换 → 4, 5
• 第 2 轮对 4 个数进行了 3 组比较，使第二大的数位于最大的数的左侧。

第 3 轮

• 第 3 轮，第 1 组
  • 【比较】1 与 3
  • 【结果】1 不动，3, 2, 4, 5
• 第 3 轮，第 2 组
  • 【比较】3 与 2
  • 【结果】2 ← 交换 → 3, 4, 5
• 第 3 轮对 3 个数进行了 2 组比较，使第三大的数位于第二大的数的左侧。

第 4 轮

• 第 4 轮，第 1 组
  • 【比较】1 与 2
  • 【结果】1 不动，2, 3, 4, 5
• 第 4 轮对 2 个数进行了 1 组比较，使第四大的数位于第三大的数的左侧。
• 剩余的第五大也就是最小的数位于序列的左端。

总结

• 当待排序数的个数为 n 时，需要进行 n − 1 轮排序。
• 每一轮待排序数的个数为 m 时，需要进行 m − 1 组比较。
• 每一轮排序后，本轮待排序数中的最大值都将位于本轮待排序数的右端。

二、C 语言实现

#include <stdio.h>

int main(void) {
    int a[] = {5, 1, 4, 3, };
     n = (a) / (a[]); 
     i = ;
     j = ;
     temp = ;
     swapped = ;

     (i = ; i < n - ; i++) { 
        swapped = ;
         (j = ; j < n - i - ; j++) { 
             (a[j] > a[j + ]) { 
                temp = a[j + ];
                a[j + ] = a[j];
                a[j] = temp;
                swapped = ;
            }
        }
        
         ( == swapped) {
            ;
        }
    }

    
     (i = ; i < n; i++) {
        (, a[i]);
    }
    ();
     ;
}