Java排序算法之冒泡排序

最新推荐文章于 2025-07-25 14:43:26 发布

即将

最新推荐文章于 2025-07-25 14:43:26 发布

阅读量206

点赞数 1

CC 4.0 BY-SA版权

分类专栏：算法排序

本文链接：https://blog.youkuaiyun.com/weixin_43209848/article/details/98891447

算法排序专栏收录该内容

2 篇文章

订阅专栏

本文详细介绍了冒泡排序的原理及实现过程，通过具体实例演示了排序步骤，对比了普通冒泡排序与优化后冒泡排序的效率差异。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

冒泡排序原理：就像石头沉入水底一样，选取数组中最大的元素放在数组最后的位置

每次选取数组中的第一个元素与其后面的元素依次进行比较，若前一个元素比后一个元素大，则进行位置交换

例如：数组 int[] a = {9，5，4，2，7，3}

第一趟：5，9，4，2，7，3 （9比5大，交换位置）

5，4，9，2，7，3 （9比4大，交换位置）

5，4，2，9，7，3 （9比2大，交换位置）

5，4，2，7，9，3 （9比7大，交换位置）

5，4，2，7，3，9 （9比3大，交换位置）

这样数组中最大的就到了最后一个位置：5，4，2，7，3，9

第二趟：4，5，2，7，3，9 （5比4大，交换位置）

4，2，5，7，3，9 （5比2大，交换位置）

4，2，5，7，3，9 （7比5大，不交换位置）

4，2，5，3，7，9 （7比3大，交换位置）

因为9已经是最大的数了，所以7不会和9比较

这样数组数组中第二大的元素也找到了位置：4，2，5，3，7，9

第三趟：2，4，5，3，7，9 （4比2大，交换位置）

2，4，5，3，7，9 （4比5小，不交换位置）

2，4，3，5，7，9 （5比3大，交换位置）

所以现在的顺序为：2，4，3，5，7，9

第四趟：2，4，3，5，7，9 （2比4小，不交换位置）

2，3，4，5，7，9 （3比4小，交换位置）

顺序为：2，3，4，5，7，9

第五趟：2，3，4，5，7，9 （2比3小不交换位置）

综上可以看出：需要数组长度-1趟，即a.length-1,每趟比较的次数为数组长度-1-趟数

public class BubbleSort {
	//冒泡的时间复杂度为O（n^2）

	//优化后的冒泡排序
	public static void bubbleSort1(int[] arr) {
		int temp = 0;//交换的临时变量
		boolean flag = false;	//判断是否发生交换，若交换过，则置为true，若没有交换过，说明数组已经有序，直接跳出循环结束
		for(int i = 0;i < arr.length-1;i++) {
			for(int j = 0;j < arr.length-1-i;j++) {
				if(arr[j] > arr[j+1]) {
					flag = true;
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
			System.out.println("优化后第"+(i+1)+"趟排序为");
			System.out.println(Arrays.toString(arr));
			if(!flag) {
				break;
			}else {
				flag = false;
			}
		}
	}
	
	public static void bubbleSort(int[] arr) {
		int temp = 0;//交换的临时变量
		for(int i = 0;i < arr.length-1;i++) {
			for(int j = 0;j < arr.length-1-i;j++) {
				if(arr[j] > arr[j+1]) {
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
			System.out.println("第"+(i+1)+"趟排序为");
			System.out.println(Arrays.toString(arr));
		}
	}
	public static void main(String[] args) {
		int[] arr = {9，5，4，2，7，3};
		//BubbleSort.bubbleSort(arr);
		BubbleSort.bubbleSort1(arr);
}
}

冒泡排序结果为

第1趟排序为
[5, 4, 2, 7, 3, 9]
第2趟排序为
[4, 2, 5, 3, 7, 9]
第3趟排序为
[2, 4, 3, 5, 7, 9]
第4趟排序为
[2, 3, 4, 5, 7, 9]
第5趟排序为
[2, 3, 4, 5, 7, 9]

优化后的冒泡排序用数组int a[] = {1,2,5,6,9,8,7}测试：

下面是优化前的排序结果

第1趟排序为
[1, 2, 5, 6, 8, 9]
第2趟排序为
[1, 2, 5, 6, 8, 9]
第3趟排序为
[1, 2, 5, 6, 8, 9]
第4趟排序为
[1, 2, 5, 6, 8, 9]
第5趟排序为
[1, 2, 5, 6, 8, 9]

优化后的排序结果

优化后第1趟排序为
[1, 2, 5, 6, 8, 9]
优化后第2趟排序为
[1, 2, 5, 6, 8, 9]

可以知道，优化后的冒泡排序明显减少了比较趟数，但优化后的算法对一个大部分有序的数组有明显的作用，算法速度明显加快了