1. 基本思想
待排序元素从左向右两两相互比较,大的放后边,小的放前边,一趟排序下来最后一个既就是最大的数,第二趟排序的时候由于最后一个数已经是最大的,所以可以比较前边n-1个,同样大的在后,小的在前,第二趟下来后边2个元素已经按照从小到大顺序有序,以此类推,每次冒出一个最大的数。
同样,若排序是从大到小,那么小的在后,大的数在前,每次冒出一个最小的数。
2. 算法示例
待排序元素: 23 13 14 13 45 12 8 5 41 3
第一趟的第1次排序:13 23 14 13 45 12 8 5 41 3
第一趟的第2次排序:13 14 23 13 45 12 8 5 41 3
第一趟的第3次排序:13 14 13 23 45 12 8 5 41 3
第一趟的第4次排序:13 14 13 23 45 12 8 5 41 3
第一趟的第5次排序:13 14 13 23 12 45 8 5 41 3
第一趟的第6次排序:13 14 13 23 12 8 45 5 41 3
第一趟的第7次排序:13 14 13 23 12 8 5 45 41 3
第一趟的第8次排序:13 14 13 23 12 8 5 41 45 3
第一趟的第9次排序:13 14 13 23 12 8 5 41 3 45
第二趟的第1次排序:13 14 13 23 12 8 5 41 3 45
第二趟的第2次排序:13 13 14 23 12 8 5 41 3 45
第二趟的第3次排序:13 13 14 23 12 8 5 41 3 45
第二趟的第4次排序:13 13 14 12 23 8 5 41 3 45
第二趟的第5次排序:13 13 14 12 8 23 5 41 3 45
第二趟的第6次排序:13 13 14 12 8 5 23 41 3 45
第二趟的第7次排序:13 13 14 12 8 5 23 41 3 45
第二趟的第8次排序:13 13 14 12 8 5 23 3 41 45
………………………..
3. 算法实现
package sort;
public classBubleSort {
int a[] = { 34, 25, 43, 56,12, 3, 1, 98, 78 };
int temp = 0;
int i = 0;
int j = 0;
// 由小到大排序,每次冒出一个最大的数
public void buble() {
for (i = 0; i < a.length - 1; i++) {
for (j = 0; j < a.length - 1 - i; j++) {
if (a[j] > a[j + 1]) {
temp = a[j + 1];
a[j + 1] = a[j];
a[j] = temp;
}
}
}
for (i = 0; i <= a.length - 1; i++) {
System.out.println(a[i]);
}
System.out.println(' ');
}
// 由大到小排序,每次冒出一个最小的数
public void bublen() {
for (i = 0; i < a.length - 1; i++) {
for (j = 0; j < a.length - 1 - i; j++) {
if (a[j] < a[j + 1]) {
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
for (i = 0; i <= a.length - 1; i++) {
System.out.println(a[i]);
}
}
public static void main(String args[]) {
BubleSortb = newBubleSort();
b.buble();
b.bublen();
}
}
4. 算法分析
我们从算法的稳定性、复杂性、应用场景来分析冒泡算法。
稳定性指的是,若待排序元素中两个数值大小相同d的r[i],r[j],排完序之后,r[i]仍在r[j]前面,那么此算法就是稳定的。
冒泡算法两两比较,若是从小到大排序,那么两两比较之后,大的在后,小的在前,数值一样的保持位置不变,所以冒泡排序算法是稳定的。
复杂度分析:两个循环,那么时间复杂度是0(n2);在排序过程中借助临时元素,所以空间复杂度0(1)。
应用场景:由于复杂度为0(n2),所以当待排序元素较少,也就是n较小时,用冒泡排序算法比较快,也比较简单。