冒泡排序Java实现

相关特点

数据结构 ---------- 数组
最差时间复杂度 ---- O(n^2)
最优时间复杂度 ---- 如果能在内部循环第一次运行时,使用一个旗标来表示有无需要交换的可能,可以把最优时间复杂度降低到O(n)
平均时间复杂度 ---- O(n^2)
所需辅助空间 ------ O(1)
稳定性 ------------ 稳定

基本思想

比较两个相邻的元素，将值大的元素交换至右端。

算法描述

依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：从后往前比较，首先比较倒数第1个和倒数第2个数，将小数放前，大数放后。然后比较倒数第2个数和倒数第3个数，将小数放前，大数放后，如此继续，直至比较第一第二两个数，将小数放前，大数放后。重复第一趟步骤，直至全部排序完成。

举例说明

要排序数组：int[] arr={6,3,8,2,9,1};   

 

第一趟排序：i=0

　　　　第一次排序：1和9比较，9大于1，交换位置：6 3 8 2 1 9

　　　　第二次排序：1和2比较，2大于1，交换位置：6 3 8 1 2 9

　　　　第三次排序：1和8比较，8大于1，交换位置：6 3 1 8 2 9

　　　　第四次排序：1和3比较，3大于1，交换位置：6 1 3 8 2 9

　　　　第五次排序：1和6比较：6大于1，交换位置：1 6 3 8 2 9

　　　　第一趟总共进行了5次比较， 排序结果：1 6 3 8 2 9

---------------------------------------------------------------------

第二趟排序：i=1

　　　　第一次排序：9和2比较，9大于2，不交换位置：1 6 3 8 2 9

　　　　第二次排序：2和8比较，8大于2，交换位置：1 6 3 2 8 9

　　　　第三次排序：2和3比较，3大于2，交换位置：1 6 2 3 8 9

　　　　第四次排序：2和6比较，6大于2，交换位置：1 2 6 3 8 9

　　　　第二趟总共进行了4次比较， 排序结果： 1 2 6 3 8 9  
 

---------------------------------------------------------------------

第三趟排序：i=2

　　　　第一次排序：9和8比较，9大于8，不交换位置： 1 2 6 3 8 9

　　　　第二次排序：8和3比较，8大于3，不交换位置：1 2 6 3 8 9

　　　　第三次排序：3和6比较，3小于6，交换位置： 1 2 3 6 8 9

　　　　第三趟总共进行了3次比较， 排序结果：1 2 3 6 8 9

---------------------------------------------------------------------

 

第四趟排序：i=3

             第一次排序：9和8比较，9大于8，不交换位置： 1 2 3 6 8 9

 

　　　　第二次排序：8和6比较，8大于6，不交换位置：1 2 3 6 8 9

　　　　第四趟总共进行了2次比较， 排序结果： 1 2 3 6 8 9

---------------------------------------------------------------------

第五趟排序：i=4

　　　　

第一次排序：9和8比较，9大于8，不交换位置： 1 2 3 6 8 9

　　　　第五趟总共进行了1次比较， 排序结果：  1  2  3  6  8  9

---------------------------------------------------------------------

最终结果：1  2  3  6  8  9

代码实现

package Sort;

public class BubbleSort {
	public static void sort(long[] arr) {
		long temp = 0;
		for (int i = 0; i < arr.length-1; i++) {//9个数相比较只需要比较8次，因为头和尾不需要相互比较
			for (int j = arr.length-1 ; j > i; j--) { //从后往前挨着比较,
				if (arr[j] < arr[j-1]) {//j到i的前一位即可，因为j-1即为i,从小到大排序
					temp = arr[j];
					arr[j] = arr[j-1];
					arr[j-1] = temp;
				}
			}
		}
	} 


	public static void main(String[] args) {
		long[] arr = new long[]{6,3,8,2,9,1};
		sort1(arr);
		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]+" ");
		}
		System.out.print("]");
	}
}

 上面这中是最普通的冒泡排序，如果字符串或者数字串本身一部分存在序列，例如 12345987 其中12345已经排好序列，但是上面这种排序方式还是会进行比较，这样会造成不必要的时间浪费。

        改进方式1：设置一个标志flag，如果发生了数据交换则flag=true，否则为false。

/**
  * 优化
  * @param arr
  */
	public static void sort1(long[] arr) {
		long temp = 0;
		boolean flag = true;// flag等于true表示循环没有结束，false表示循环已经结束
		for (int i = 0; i < arr.length-1; i++) {
			 // 如果以后的循环不改变flag的值，说明没有发生数组交换
                         // 也就是说这个数组已经是排好序的了。
			flag = false;
			for (int j = arr.length-1 ; j >i ; j--) {
				if (arr[j] < arr[j-1]) {
					temp = arr[j];
					arr[j] = arr[j-1];
					arr[j-1] = temp;
					flag = true;
				}
			}
		}
	}

参考博文：https://blog.csdn.net/weixin_41181915/article/details/79345042

                 https://www.cnblogs.com/shen-hua/p/5422676.html