目录
1.冒泡排序介绍
冒泡排序是一种比较简单的排序方法，以数组升序的情况为例，它的原理是从第一个元素开始，每个元素都与其相邻的元素做比较，如果前一个元素比后一个元素大，则交换两个元素的位置，每一轮排序都确定一个最大值。它是一种稳定的排序方法，因为两个元素相等时不会做交换，相对位置不会发生改变。
2. O(n^2)的实现方法
/**
* @author Zeng
* @date 2020/2/27 16:39
*/
public class BubbleSort1 {
public static void swap(int[] arr, int i, int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void bubbleSort(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(arr, j, j+1);
}
}
}
}
public static void main(String[] args) {
int[] arr = new int[]{5, 3, 1, 6, 2, 4};
bubbleSort(arr);
for (int i : arr) {
System.out.print(i+ " ");
}
}
}
//第1趟排序结果:3 1 5 2 4 6
//第2趟排序结果:1 3 2 4 5 6
//第3趟排序结果:1 2 3 4 5 6
//第4趟排序结果:1 2 3 4 5 6
//第5趟排序结果:1 2 3 4 5 6
//第6趟排序结果:1 2 3 4 5 6 3. 优化思路1：提前到达有序
如果数组本来就有序，那么使用上面的代码依旧会对数组进行6轮排序，但是一个元素都没有交换，所以我们为数组添加一个标志tag，如果某一轮排序中没有数组元素进行交换，那么就代表此时的数组已经有序，无需进行下一轮的排序。
/**
* @author Zeng
* @date 2020/2/27 16:39
*/
public class BubbleSort2 {
public static void swap(int[] arr, int i, int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void bubbleSort(int[] arr){
//判断某一轮排序有没有进行元素交换,如果为false则代表数组已有序
boolean flag;
for (int i = 0; i < arr.length; i++){
flag = false;
for (int j = 0; j < arr.length - i - 1; j++){
if(arr[j] > arr[j+1]){
swap(arr, j, j+1);
flag = true;
}
}
if(!flag){
return ;
}
System.out.print("第"+(i+1)+"趟排序结果:");
for (int k : arr) {
System.out.print(k+" ");
}
System.out.println();
}
}
public static void main(String[] args) {
int[] arr = new int[]{1, 2, 3, 4, 6, 5};
bubbleSort(arr);
}
}
//第1趟排序结果:1 2 3 4 5 6 4. 优化思路2：获取交换的最后一个元素下标
在某一趟排序中有可能在某个元素之后都没有做交换操作，那么可以知道该元素以后已经有序，下一轮排序不需要对该元素以后的其它元素做排序，所以我们可以用一个变量pos进行记录当前一轮排序中交换元素的最后一个位置，每一轮排序只针对第1个元素到第pos个元素进行，第pos+1个元素开始已经保持有序，同样我们采用优化思路1，如果某一趟排序没有元素做交换，那么证明数组已经有序，不需要进行下一轮的排序。
扫描二维码关注公众号，回复：
9595335 查看本文章
/**
* @author Zeng
* @date 2020/2/28 8:28
*/
public class BubbleSort3 {
public static void swap(int[] arr, int i, int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void bubbleSort(int[] arr){
int position = arr.length - 1;
int tmpPosition = position;
boolean flag;
for (int i = 0; i < arr.length; i++){
flag = false;
for (int j = 0; j < tmpPosition; j++){
if(arr[j] > arr[j+1]){
swap(arr, j, j+1);
position = j;
flag = true;
}
}
if(!flag){
return ;
}
System.out.print("第"+(i+1)+"趟排序结果:");
for (int k : arr) {
System.out.print(k+" ");
}
System.out.println("最后交换元素的位置pos："+position);
tmpPosition = position;
}
}
public static void main(String[] args) {
int[] arr = new int[]{3,2,1,5,4,6};
bubbleSort(arr);
}
}
//第1趟排序结果:2 1 3 4 5 6 最后交换元素的位置pos：3
//第2趟排序结果:1 2 3 4 5 6 最后交换元素的位置pos：05. 总结
冒泡排序是九大排序算法中较为简单的排序算法，但是也要考虑其优化，目前我只能想到这两种优化方法，如果大家有其它优化思路可以分享给我，如果代码有什么错误欢迎指出，能力有限，时间有限，乐意与大家交流！
