再论经典冒泡排序算法
冒泡排序基本原理：
从队列的底部开始，依次与前一个元素相比较，如果条件跟排序条件不符合，就交换。这样一轮比较下来，第一个元数就是最小的元素了。由于过程类似于夏天河底冒出汽泡，汽泡比水轻而上浮，所以叫冒泡排序。
有一种改进的形态，叫下沉法，类似于往河中扔东西，其过程是往下沉的。
以下用到的公用方法：
/**
* 是否升序排列，true：升序排列, false：降序排列
*/
private static boolean isAscending = true;
/**
* 描述：判断前面元素跟后面元素的关系是否升序/降序。
*
* @param a 数组
* @param prev 前面元素
* @param next 后面元素
* @param isAscending 是否升序排列，true：升序排列, false: 降序排列
* @return
*/
private static boolean judge(long prev, long next, boolean isAscending) {
return isAscending ? prev < next : prev > next;
}
/**
* 描述：交换元素。
*
* @param a 数组
* @param i 元素1
* @param j 元素2
*/
private static void swap(int[] a, int i, int j) {
int t = a[i];
a[i] = a[j];
a[j] = t;
}
/**
* 描述：排序测试。
*
* @param args 命令行参数
*/
public static void main(String[] args) {
int[] a = { 1, 3, 7, 8, 5, 9, 6, 2, 4, 0 };
System.out.println("数组长度：" + a.length);
System.out.println("数组原有顺序：" + Arrays.toString(a));
SortUtil.bubbleSort(a);
System.out.println("数组排序后顺序：" + Arrays.toString(a));
}
1.经典冒泡排序法（上浮法）：
/**
* 描述：冒泡排序（交换排序）。上浮法。
*
* 从未排序队列中，取出队尾元素，与前一元素比较并确定是否交换。重复前面的操作步骤。
*
* @param a 数组
*/
public static void bubbleSort(int[] a) {
int loopCount = 0;
int swapCount = 0;
for (int i = 0, n = a.length; i < n; i++) {
// i之前的为已排序的有序队列(严格：已是最终结果的一部分)
for (int j = n - 1; j > i; j--) {
if (judge(a[j - 1], a[j], !isAscending)) {
swap(a, j, j - 1);
swapCount++;
}
loopCount++;
}
}
System.out.println("loopCount=" + loopCount);
System.out.println("swapCount=" + swapCount);
}
2.形态改变冒泡排序法（下沉法）：
/**
* 描述：冒泡排序（交换排序）。下沉法。
*
* 从未排序队列中，取出队首元素，与后一元素比较并确定是否交换。重复前面的操作步骤。
*
* @param a 数组
*/
public static void bubbleSort4(int[] a) {
int loopCount = 0;
int swapCount = 0;
for (int i = 0, n = a.length; i < n; i++) {
for (int j = 0, m = n - i - 1; j < m; j++) {
if (judge(a[j], a[j + 1], !isAscending)) {
swap(a, j, j + 1);
swapCount++;
}
loopCount++;
}
}
System.out.println("loopCount=" + loopCount);
System.out.println("swapCount=" + swapCount);
}
3.经典冒泡法改进（快速返回的）：
场景：在基本有序的队列中，可能有很多环节只做了比较，没做交换，如果一整轮比较都未交换过，说明接下来不用再处理了，都是有序了。
/**
* 描述：冒泡排序（交换排序）。上浮法。改进型。
*
* 从未排序队列中，取出队尾元素，与前一元素比较并确定是否交换。重复前面的操作步骤。
*
* @param a 数组
*/
public static void bubbleSort2(int[] a) {
int loopCount = 0;
int swapCount = 0;
// 判断处理过程中是否有交换
boolean isExchanged = true;
for (int i = 0, n = a.length; i < n && isExchanged; i++) {
// i之前的为已排序的有序队列(严格：已是最终结果的一部分)
isExchanged = false;
for (int j = n - 1; j > i; j--) {
if (judge(a[j - 1], a[j], !isAscending)) {
swap(a, j, j - 1);
swapCount++;
isExchanged = true;
}
loopCount++;
}
}
System.out.println("loopCount=" + loopCount);
System.out.println("swapCount=" + swapCount);
}
4.经典冒泡改进（快速返回的，利用上次排序结果）：
场景：在基本有序的队列中，可能有很多环节只做了比较，没做交换，如果一整轮比较都未交换过，说明接下来不用再处理了，都是有序了。但如果只做了部分交换，则可以跳过那部分没交换的数据。
/**
* 描述：冒泡排序（交换排序）。上浮法。改进型。
*
* 从未排序队列中，取出队尾元素，与前一元素比较并确定是否交换。重复前面的操作步骤。
*
* @param a 数组
*/
public static void bubbleSort3(int[] a) {
int loopCount = 0;
int swapCount = 0;
// 判断处理过程中是否有交换
boolean isExchanged = true;
// 上次交换时的索引
int lastExchangeIndex = 0;
for (int i = 0, n = a.length; i < n && isExchanged; i++) {
// i之前的为已排序的有序队列(严格：已是最终结果的一部分)
isExchanged = false;
lastExchangeIndex = i;
for (int j = n - 1; j > i; j--) {
if (judge(a[j - 1], a[j], !isAscending)) {
swap(a, j, j - 1);
swapCount++;
isExchanged = true;
lastExchangeIndex = j -1;
}
loopCount++;
}
i = lastExchangeIndex;
}
System.out.println("loopCount=" + loopCount);
System.out.println("swapCount=" + swapCount);
}