-
最简单的冒泡排序规则及实现
-
冒泡排序的简单优化
-
冒泡排序再优化
-
基于冒泡排序的升级版-鸡尾酒排序
-
最简单的冒泡排序及实现 冒泡排序可以说是一种非常基本的排序了，他的排序规则是每次将大数挪到序列末尾，就像冒泡一样。时间复杂度为O(n^2)
冒泡排序初版：
package sort;
import java.util.Arrays;
/**
* @Author: sunsuhai
* @Date: 2018/12/25 18:00
*/
public class bulubuluSort {
public static void main(String[] args) {
int[] arr = {9, 8, 7, 6, 5, 4, 8, 2, 1};
buluSort(arr);
System.out.println(Arrays.toString(arr));
}
private static void buluSort(int[] arr) {
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
Swap.swap(arr, j, j + 1);
}
}
}
}
}
代码非常简单，使用双循环来进行排序。外部循环控制所有的回合，内部循环代表每一轮的冒泡处理，先进行元素比较，再进行元素交换。
原始的冒泡排序有哪些优化点呢？
以5，8，6，3，9，2，1，7这个数列为例，当排序算法分别执行到第六、第七、第八轮的时候，数列状态如下：
第六轮： 1 ， 2 ，3 ，5 ，6 ，7 ，8 ，9
第七轮： 1 ， 2 ，3 ，5 ，6 ，7 ，8 ，9
第八轮： 1 ， 2 ，3 ，5 ，6 ，7 ，8 ，9
很明显可以看出，自从经过第六轮排序，整个数列已然是有序的了。可是我们的排序算法仍然“兢兢业业”地继续执行第七轮、第八轮。 这种情况下，如果我们能判断出数列已经有序，并且做出标记，剩下的几轮排序就可以不必执行，提早结束工作。
冒泡排序2.0
private static void buluSort2(int[] arr) {
for (int i = 0; i < arr.length; i++) {
//设置有序标志，默认为0
boolean isSorted = true;
for (int j = 0; j < arr.length - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
Swap.swap(arr, j, j + 1);
//如果发生了元素交换，说明此时的序列不是有序的，将标志置为false
isSorted = false;
}
}
//如果序列有序，结束循环
if (isSorted){
break;
}
}
}
这一版代码做了小小的改动，利用布尔变量isSorted作为标记。如果在本轮排序中，元素有交换，则说明数列无序；如果没有元素交换，说明数列已然有序，直接跳出大循环。
为了说明问题，我们再给定一个序列
4 ，3 ，2 ，1 ，5 ，6 ，7 ，8 这个数列的特点是前半部分（3，4，2，1）无序，后半部分（5，6，7，8）升序，并且后半部分的元素已经是数列最大值。
这个问题的关键点在哪里呢？关键在于对数列有序区的界定。按照现有的逻辑，有序区的长度和排序的轮数是相等的。比如第一轮排序过后的有序区长度是1，第二轮排序过后的有序区长度是2 ......
实际上，数列真正的有序区可能会大于这个长度，比如例子中仅仅第二轮，后面5个元素实际都已经属于有序区。因此后面的许多次元素比较是没有意义的。如何避免这种情况呢？我们可以在每一轮排序的最后，记录下最后一次元素交换的位置，那个位置也就是无序数列的边界，再往后就是有序区了。
冒泡排序3.0
private static void buluSort3(int[] arr) {
//最后一次交换元素的位置
int lastSwapIndex = 0;
//无序数组的边界
int sortBoder = arr.length - 1;
for (int i = 0; i < arr.length; i++) {
//设置有序标志，默认为0
boolean isSorted = true;
for (int j = 0; j < sortBoder; j++) {
if (arr[j] > arr[j + 1]) {
Swap.swap(arr, j, j + 1);
//如果发生了元素交换，说明此时的序列不是有序的，将标志置为false
isSorted = false;
//把无序数列的边界更新为最后一次交换元素的位置
lastSwapIndex = j;
}
}
sortBoder = lastSwapIndex;
//如果序列有序，结束循环
if (isSorted){
break;
}
}
}
因为冒泡排序是一种一头冒泡的排序，所以有了另一种排序的方法，让他两头冒泡，叫鸡尾酒排序，我也不知道为啥叫鸡尾酒排序....
private static void buluSort4(int array[]) {
int tmp = 0;
//记录右侧最后一次交换的位置
int lastRightExchangeIndex = 0;
//记录左侧最后一次交换的位置
int lastLeftExchangeIndex = 0;
//无序数列的右边界，每次比较只需要比到这里为止
int rightSortBorder = array.length - 1;
//无序数列的左边界，每次比较只需要比到这里为止
int leftSortBorder = 0;
for (int i = 0; i < array.length / 2 - 1; i++) {
//有序标记，每一轮的初始是true
boolean isSorted = true;
//奇数轮，从左向右比较和交换
for (int j = leftSortBorder; j < rightSortBorder; j++) {
if (array[j] > array[j + 1]) {
Swap.swap(array,j,j+1);
//有元素交换，所以不是有序，标记变为false
isSorted = false;
lastRightExchangeIndex = j;
}
}
rightSortBorder = lastRightExchangeIndex;
if (isSorted) {
break;
}
//偶数轮，从右向左比较和交换
for (int j = rightSortBorder; j > leftSortBorder; j--) {
if (array[j] < array[j - 1]) {
Swap.swap(array,j,j-1);
//有元素交换，所以不是有序，标记变为false
isSorted = false;
lastLeftExchangeIndex = j;
}
}
leftSortBorder = lastLeftExchangeIndex;
if (isSorted) {
break;
}
}
}
代码外层的大循环控制着所有排序回合，大循环内包含两个小循环，第一个循环从左向右比较并交换元素，第二个循环从右向左比较并交换元素。
以2,3,4,5,6,7,8,1为例，使用原先的排序方式，需要进行8轮操作，使用改进后的算法，三轮就可以结束。
鸡尾酒排序算法适用场景： 序列中的大部分元素已经有序
