十大排序之冒泡排序

冒泡排序作为十大排序之一，是一种简单且稳定的排序算法

算法思想可以联想为向湖中下石头和较轻的石头变成泡泡上浮的过程
想象每一块石头处在相应的高度，从上往下相邻两个石头进行比较，较大的石头往下沉，替代下一石头的位置
较轻的石头像泡泡一样往上浮一个单位，直到这一轮最重的石头沉到湖底，此趟比较才结束
此时，最重的石头已经再湖底，不需要再参加下一趟排序，可以想象为以及与湖底融为一体了
可以得到，每次排序都会将最重的石头往下沉并和湖底融为一体
因此，排序至多需要 n-1 趟（最后一趟只剩一个元素，因此不会再排序），最少需要1趟（已经有序）

算法思想：双重for循环，外层循环控制每次排序元素的长度（被排序的元素个数依次递减），内层循环遍历每轮循环的元素

适用场景：数据量小、有序或者部分有序的数列

时间复杂度：O(n^2) 空间复杂度：O(1)

代码实现：（未优化版）

package com.gxwz.vo;

import java.util.Arrays;
/**
 * Java十大排序之冒泡排序（未优化版）
 * @author com
 *
 */
public class Sorts {

	public static void main(String[] args) {
		int[] arr = {49,26,2,9,16,0,10,100,24};
		System.out.println(Arrays.toString(insertSort(arr)));
	}
	public static int[] insertSort(int[] A) {
		int length = A.length;
		int temp = 0;
		for(int i=length-1;i>0;i--) {
			for(int j=0;j<i;j++) {
				if(A[j]>A[j+1]) {
					temp = A[j];
					A[j] = A[j+1];
					A[j+1] = temp;
				}
			}
		}
		return A;
	}
}

运行结果：

[0, 2, 9, 10, 16, 24, 26, 49, 100]

原数据：

[49, 26, 2, 9, 16, 0, 10, 100, 24]

第 1 趟排序：

[26, 49, 2, 9, 16, 0, 10, 100, 24]
[26, 2, 49, 9, 16, 0, 10, 100, 24]
[26, 2, 9, 49, 16, 0, 10, 100, 24]
[26, 2, 9, 16, 49, 0, 10, 100, 24]
[26, 2, 9, 16, 0, 49, 10, 100, 24]
[26, 2, 9, 16, 0, 10, 49, 100, 24]
[26, 2, 9, 16, 0, 10, 49, 100, 24]
[26, 2, 9, 16, 0, 10, 49, 24, 100]

第 2 趟排序：

[2, 26, 9, 16, 0, 10, 49, 24, 100]
[2, 9, 26, 16, 0, 10, 49, 24, 100]
[2, 9, 16, 26, 0, 10, 49, 24, 100]
[2, 9, 16, 0, 26, 10, 49, 24, 100]
[2, 9, 16, 0, 10, 26, 49, 24, 100]
[2, 9, 16, 0, 10, 26, 49, 24, 100]
[2, 9, 16, 0, 10, 26, 24, 49, 100]

第 3 趟排序：

[2, 9, 16, 0, 10, 26, 24, 49, 100]
[2, 9, 16, 0, 10, 26, 24, 49, 100]
[2, 9, 0, 16, 10, 26, 24, 49, 100]
[2, 9, 0, 10, 16, 26, 24, 49, 100]
[2, 9, 0, 10, 16, 26, 24, 49, 100]
[2, 9, 0, 10, 16, 24, 26, 49, 100]

第 4 趟排序：

[2, 9, 0, 10, 16, 24, 26, 49, 100]
[2, 0, 9, 10, 16, 24, 26, 49, 100]
[2, 0, 9, 10, 16, 24, 26, 49, 100]
[2, 0, 9, 10, 16, 24, 26, 49, 100]
[2, 0, 9, 10, 16, 24, 26, 49, 100]

第 5 趟排序：

[0, 2, 9, 10, 16, 24, 26, 49, 100]
[0, 2, 9, 10, 16, 24, 26, 49, 100]
[0, 2, 9, 10, 16, 24, 26, 49, 100]
[0, 2, 9, 10, 16, 24, 26, 49, 100]

第 6 趟排序：

[0, 2, 9, 10, 16, 24, 26, 49, 100]
[0, 2, 9, 10, 16, 24, 26, 49, 100]
[0, 2, 9, 10, 16, 24, 26, 49, 100]

第 7 趟排序：

[0, 2, 9, 10, 16, 24, 26, 49, 100]
[0, 2, 9, 10, 16, 24, 26, 49, 100]

第 8 趟排序：

[0, 2, 9, 10, 16, 24, 26, 49, 100]
[0, 2, 9, 10, 16, 24, 26, 49, 100]

优化版：

import java.util.Arrays;
/**
 * Java十大排序之冒泡排序（优化版）
 * @author com
 *
 */
public class Sorts {

	public static void main(String[] args) {
		int[] arr = {49,26,2,9,16,0,10,100,24};
		System.out.println(Arrays.toString(insertSort(arr)));
	}
	public static int[] insertSort(int[] A) {
		int length = A.length;
		int temp = 0;
		boolean flag;
		for(int i=length-1;i>0;i--) {
			flag = true;
			for(int j=0;j<i;j++) {
				if(A[j]>A[j+1]) {
					temp = A[j];
					A[j] = A[j+1];
					A[j+1] = temp;
					flag = false;
				}
			}
			if(flag) break;
		}
		return A;
	}
}

优化思路：

在每次循环前设置一个flag，如果此趟排序有元素交换则为false，否则为true。

在每次交换代码执行之后再判断flag的状态，如果false则继续执行，否则结束循环。

优点：如果元素在n-1趟排序之前已经排好序，后面的循环不需要再继续了。