冒泡排序是计算机的一种排序方法，它的时间复杂度为O（n^2），虽然不及堆排序、快速排序的O（nlogn，底数为2），但是有两个优点：
1.“编程复杂度”很低，很容易写出代码；
2.具有稳定性，这里的稳定性是指原序列中相同元素的相对顺序仍然保持到排序后的序列，而堆排序、快速排序均不具有稳定性。
不过，一路、二路归并排序、不平衡二叉树排序的速度均比冒泡排序快，且具有稳定性，但速度不及堆排序、快速排序。冒泡排序是经过n-1趟子排序完成的，第i趟子排序从第1个数至第n-i个数，若第i个数比后一个数大（则升序，小则降序）则交换两数。
冒泡排序算法稳定，O(1)的额外的空间，比较和交换的时间复杂度都是O(n^2)，自适应，对于已基本排序的算法，时间复杂度为O(n)。冒泡算法的许多性质和插入算法相似，但对于系统开销高一点点。
排序过程
设想被排序的数组R［1..N］垂直竖立，将每个数据元素看作有重量的气泡，根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R，凡扫描到违反本原则的轻气泡，就使其向上"漂浮"，如此反复进行，直至最后任何两个气泡都是轻者在上，重者在下为止。
代码实现
- public class BubbleSortTest {
- public static void main(String[] args) {
- int[] data5 = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7};
- print(data5);
- bubbleSort(data5);
- System.out.println("排序后的数组：");
- print(data5);
- }
- public static void swap(int[] data, int i, int j) {
- if (i == j) {
- return;
- }
- data[i] = data[i] + data[j];
- data[j] = data[i] - data[j];
- data[i] = data[i] - data[j];
- }
- public static void bubbleSort(int[] data) {
- for (int i = 0; i < data.length - 1; i++) {
- // 记录某趟是否发生交换，若为false表示数组已处于有序状态
- boolean isSorted = false;
- for (int j = 0; j < data.length - i - 1; j++) {
- if (data[j] > data[j + 1]) {
- swap(data, j, j + 1);
- isSorted = true;
- print(data);
- }
- }
- if (!isSorted) {
- // 若数组已处于有序状态，结束循环
- break;
- }
- }
- }
- public static void print(int[] data) {
- for (int i = 0; i < data.length; i++) {
- System.out.print(data[i] + "\t");
- }
- System.out.println();
- }
- }
运行结果
- 5 3 6 2 1 9 4 8 7
- 3 5 6 2 1 9 4 8 7
- 3 5 2 6 1 9 4 8 7
- 3 5 2 1 6 9 4 8 7
- 3 5 2 1 6 4 9 8 7
- 3 5 2 1 6 4 8 9 7
- 3 5 2 1 6 4 8 7 9
- 3 2 5 1 6 4 8 7 9
- 3 2 1 5 6 4 8 7 9
- 3 2 1 5 4 6 8 7 9
- 3 2 1 5 4 6 7 8 9
- 2 3 1 5 4 6 7 8 9
- 2 1 3 5 4 6 7 8 9
- 2 1 3 4 5 6 7 8 9
- 1 2 3 4 5 6 7 8 9
- 排序后的数组：
- 1 2 3 4 5 6 7 8 9