冒泡排序是交换排序的一种，其思想是从序列头部开始逐步往后遍历，每次遍历比较相邻两个元素，如果顺序不对则交换，n-1次遍历之后序列就完成了排序。由于每次遍历都是把最大的元素一步步让最后移动，类似于水泡慢慢浮出水面，于是得名冒泡算法。冒泡算法的思想很简单，实现起来也很容易，但是效率太低，所以即使是小数据量也很少推荐使用冒泡算法，更多的使用直接插入排序。
基本思想：
从待排序序列头部开始循环遍历n-1次，每次遍历比较相邻两个元素，如果顺序不对则交换，也就是说如果你想要从小到大排列，那么如果相邻两个元素比较结果是前面的大于后面的，则交换就可以了，那么通过一次遍历最大的元素就到达了序列的尾部，n-1次遍历之后序列就完成了排序。这里显然有可优化的空间，下面会提到。
实现要点：
第i次(i=0…n-1)遍历从0开始比较到n-1-i(n序列长度)，因为每次遍历都会将未排序部分最大的元素移动到序列尾部，所以序列尾部是有序的，故在之后的遍历过程中无需继续比较有序的部分。
算法改进：
该算法有两处可优化的地方：
- 如果一次遍历过程中未发生任何交换，即所有相邻元素的顺序都是正确的，则说明整个序列已经完成排序，故无需继续遍历。
- 每次遍历过程中记录下最后一次发生遍历的位置，则在改位置之后的部分已经是有序的，下次遍历时就可以提前结束。
实验表明以上两种改进之后的效率并未有太大的提高，第一种改进效率反而比为改进的低，第二种改进效率稍微提高一点点。虽然这两种改进从理论上来看是有一定的优化的，但是测试时使用的序列一般都是随机的，即在n-1次遍历之前完成排序以及部分有序的可能性都很小，所以这两种改进的效果都不是很明显，可能根本不会发生，反而由于加入了一些逻辑判断反而导致效率降低。不过如果是真是数据，那么之前提到的两种情况还是很可能发生的。
Java实现：
package com.vicky.sort;
import java.util.Random;
/**
* 交换排序：冒泡排序
*
* 时间复杂度：O(n^2)
*
* 空间复杂度：O(1)
*
* 稳定性：稳定
*
* @author Vicky
*
*/
public class BubbleSort {
/**
* 未改进的冒泡排序
*
* @param <T>
* @param data
*/
public static <T extends Comparable<T>> void sort(T[] data) {
long start = System.nanoTime();
if (null == data) {
throw new NullPointerException("data");
}
if (data.length == 1) {
return;
}
// n-1趟遍历
for (int i = 0; i < data.length - 1; i++) {
// 每次遍历从0开始依次比较相邻元素
for (int j = 0; j < data.length - 1 - i; j++) {
// 前面元素>后面元素则交换
if (data[j].compareTo(data[j + 1]) > 0) {
T temp = data[j];
data[j] = data[j + 1];
data[j + 1] = temp;
}
}
}
System.out.println("sort, use time:" + (System.nanoTime() - start)
/ 1000000);
}
/**
* 改进后冒泡排序
*
* 改进原理：如果一次遍历过程未发生交换，则说明序列已经是有序的，故无需再进行遍历。
*
* @param <T>
* @param data
*/
public static <T extends Comparable<T>> void sortImprove(T[] data) {
long start = System.nanoTime();
if (null == data) {
throw new NullPointerException("data");
}
if (data.length == 1) {
return;
}
boolean exchange = false;// 记录一趟遍历是否发生交换
// n-1趟遍历
for (int i = 0; i < data.length - 1; i++) {
// 每次遍历从0开始依次比较相邻元素
for (int j = 0; j < data.length - 1 - i; j++) {
// 前面元素>后面元素则交换
if (data[j].compareTo(data[j + 1]) > 0) {
T temp = data[j];
data[j] = data[j + 1];
data[j + 1] = temp;
exchange = true;
}
}
// 如果本次遍历未发生交换，则说明序列已是有序的，则无需继续遍历
if (!exchange) {
return;
}
}
System.out.println("sortImprove1, use time:"
+ (System.nanoTime() - start) / 1000000);
}
/**
* 改进后冒泡排序
*
* 改进原理：在冒泡排序的每趟扫描中，记住最后一次交换发生的位置lastexchange也能有所帮助。因为该位置之后的部分已经是有序的(未发生交换，
* 所以是有序)，
* 故下一趟排序开始的时候，只需处理0到lastexchange部分，lastexchange到n-1是有序区。同时如果未发生交换则退出即可
*
* @param <T>
* @param data
*/
public static <T extends Comparable<T>> void sortImprove2(T[] data) {
long start = System.nanoTime();
if (null == data) {
throw new NullPointerException("data");
}
if (data.length == 1) {
return;
}
int lastChange = data.length - 1;// 记录一趟遍历最后一次发生交换的位置，该位置之后是有序的
// 上次遍历发生交换则lastChange>0，继续遍历
while (lastChange > 0) {
// 本次遍历从0开始到上次遍历最后一次交换的位置结束
int end = lastChange;
lastChange = 0;
// 每次遍历从0开始依次比较相邻元素
for (int j = 0; j < end; j++) {
// 前面元素>后面元素则交换
if (data[j].compareTo(data[j + 1]) > 0) {
T temp = data[j];
data[j] = data[j + 1];
data[j + 1] = temp;
lastChange = j + 1;
}
}
}
System.out.println("sortImprove2, use time:"
+ (System.nanoTime() - start) / 1000000);
}
public static void main(String[] args) {
// 用于记录三种冒泡排序的用时
long[] useTime1 = new long[10];
long[] useTime2 = new long[10];
long[] useTime3 = new long[10];
// 循环测试10次，取均值
for (int times = 0; times < 10; times++) {
// 构建10000个元素的序列进行排序
Random ran = new Random();
Integer[] data = new Integer[10000];
for (int i = 0; i < data.length; i++) {
data[i] = ran.nextInt(10000000);
}
// 使用System.arraycopy复制三个数组分别用于排序
Integer[] data1 = new Integer[data.length];
Integer[] data2 = new Integer[data.length];
Integer[] data3 = new Integer[data.length];
System.arraycopy(data, 0, data1, 0, data.length);
System.arraycopy(data, 0, data2, 0, data.length);
System.arraycopy(data, 0, data3, 0, data.length);
// 分别记录三种冒泡排序的用时
long start = System.nanoTime();
BubbleSort.sort(data1);
useTime1[times] = (System.nanoTime() - start) / 1000000;
// SortUtils.printArray(data1);
start = System.nanoTime();
BubbleSort.sortImprove(data2);
useTime2[times] = (System.nanoTime() - start) / 1000000;
start = System.nanoTime();
// SortUtils.printArray(data2);
BubbleSort.sortImprove2(data3);
useTime3[times] = (System.nanoTime() - start) / 1000000;
// SortUtils.printArray(data3);
}
// 计算用时最大值，最小值，均值
long[] res1 = SortUtils.countArray(useTime1);
long[] res2 = SortUtils.countArray(useTime2);
long[] res3 = SortUtils.countArray(useTime3);
System.out.println("method\tmax\tmin\tavg\t");
System.out.println("sort" + "\t" + res1[0] + "\t" + res1[1] + "\t"
+ res1[2]);
System.out.println("sortImprove" + "\t" + res2[0] + "\t" + res2[1]
+ "\t" + res2[2]);
System.out.println("sortImprove2" + "\t" + res3[0] + "\t" + res3[1]
+ "\t" + res3[2]);
// 测试结果，第一种改进方法效率比不改进还差一些，
// 可能由于出现提前完成排序的可能性较小，每次遍历加入了过多的赋值以及判断操作导致效率反而降低
// 第二种改进方法还是有一些效果的
// method max min avg
// sort 1190 1073 1123
// sortImprove 1258 1097 1146
// sortImprove2 1205 1056 1099
}
}效率分析：
（1）时间复杂度
O(n^2)
冒泡排序最好的时间复杂度是O(n)，一次遍历即可，无需交换（第一种改进）。最坏情况需要遍历n-1次，比较且交换n-1-i次，故时间复杂度是O(n^2)。
（2）空间复杂度
O(1)
从空间来看，它只需要一个元素的辅助空间，用于元素的位置交换O(1)。
（3）稳定性
稳定
排序过程中只有相邻两个元素会发生交换，同时为了减少交换次数相同的元素不会进行交换，所以两个相同元素的相对位置不会发生改变。
版权声明：本文为博主原创文章，未经博主允许不得转载。
时间： 2024-10-09 11:24:21