冒泡排序是交换排序的一种,其思想是从序列头部开始逐步往后遍历,每次遍历比较相邻两个元素,如果顺序不对则交换,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)稳定性
稳定
排序过程中只有相邻两个元素会发生交换,同时为了减少交换次数相同的元素不会进行交换,所以两个相同元素的相对位置不会发生改变。
版权声明:本文为博主原创文章,未经博主允许不得转载。
原文地址:http://blog.csdn.net/vickyway/article/details/47687879