java算法笔记之冒泡排序——2021/03/26

最新推荐文章于 2023-01-29 14:09:18 发布
最新推荐文章于 2023-01-29 14:09:18 发布
阅读量166 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hyhbgydx/article/details/115227987
版权

冒泡排序 算法 优化 时间复杂度 代码实例
关键词由CSDN通过智能技术生成

排序算法

一、冒泡排序

1、概念

1）、基本介绍

冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始），依次比较相邻元素的值。若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒。

2）、优化

因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换，从而减少不必要的比较。（这里说的优化，可以在冒泡排序写好后再进行）。

2、冒泡排序应用实例

将五个无序的数：3，9，-1，10，20使用冒泡排序法将其排成一个从小到大的有序数列
在这里插入图片描述

3、冒泡排序规则

  1. 一共进行数组的大小-1次大的循环
  2. 每一趟排序的次数在逐渐的减少
  3. 如果在某趟排序中，没有发生一次交换，可以提前结束冒泡排序。这个就是优化。

4、代码实例

public class BubbleSort{
	public static void main(String[] args){
		int arr[] = {3,9,-1,10,-2};

		//冒泡排序的过程演示

		//第一趟排序，就是将最大的数排在最后
		int temp = 0; //临时变量
		for(int j = 0; j < arr.length - 1; j++){
			//如果前面的数比后面的数大，则交换
			if(arr[j] > arr[j+1]){
				temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}

		System.out.println("第一趟排序后的数组");
		System.out.println(Arrays.toString(arr));

		
		//第二趟排序，就是将第二大的数排在倒数第二位
		for(int j = 0; j < arr.length - 1 - 1; j++){
			//如果前面的数比后面的数大，则交换
			if(arr[j] > arr[j+1]){
				temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}

		System.out.println("第二趟排序后的数组");
		System.out.println(Arrays.toString(arr));



		//第三趟排序，就是将最大的数排在倒数第三位
		for(int j = 0; j < arr.length - 1 - 1 - 1; j++){
			//如果前面的数比后面的数大，则交换
			if(arr[j] > arr[j+1]){
				temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}

		System.out.println("第三趟排序后的数组");
		System.out.println(Arrays.toString(arr));



		//第四趟排序，就是将第四大的数排在倒数第四位
		for(int j = 0; j < arr.length - 1 - 1 - 1 - 1; j++){
			//如果前面的数比后面的数大，则交换
			if(arr[j] > arr[j+1]){
				temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}

		System.out.println("第四趟排序后的数组");
		System.out.println(Arrays.toString(arr));

	}
}

如果想要把数组中的内容打印出来，直接使用toString方法只会打印出数组的地址，因此需要使用Arrays的toString方法，可以从其内部实现中看出来，该方法支持入参可以是long，float，double，int，boolean，byte，object型的数组。

public class BubbleSort{
	public static void main(String[] args){
		int arr[] = {3,9,-1,10,-2};
		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));}
		}
	}
}

冒泡排序的时间复杂度：O(n²)

5、冒泡排序算法的优化

public class BubbleSort{
	public static void main(String[] args){
		int arr[] = {3,9,-1,10,-2};
		
		int temp = 0; //临时变量
		boolean flag = false; //标识变量，表示是否进行过交换

		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){ //!flag表示flag == false。表示在一趟排序中，以此交换都没有发生过
				break;
			}else{
				flag = false; //如果进行了排序，flag会变为true，这时要重置flag，以便进行下一次排序
			}
		}
	}
}

6、将冒泡排序方法封装成一个方法

public class BubbleSort{
	public static void main(String[] args){
		int arr[] = {3,9,-1,10,20};

		
		System.out.println("排序前");
		System.out.println(Arrays.toString(arr));

		//测试冒泡排序
		BubbleSort(arr);

		System.out.println("排序后");
		System.out.println(Arrays.toString(arr));
	}
	
public static void BubbleSort(int[] arr){
	int temp = 0; //临时变量
		boolean flag = false; //标识变量，表示是否进行过交换

		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){ //!flag表示flag == false。表示在一趟排序中，以此交换都没有发生过
				break;
			}else{
				flag = false; //如果进行了排序，flag会变为true，这时要重置flag，以便进行下一次排序
			}
		}
	}
}

7、测试冒泡排序的速度

public class BubbleSort{
	public static void main(String[] args){
	
		//测试冒泡排序的速度O(n²)，给80000个数据，测试
		//创建随机数组
		int[] arr = new int[80000];
		for(int i = 0; i < 80000; i++){
			arr[i] = (int)(Math.random() * 8000000);//生成在[0,8000000]范围内的数
		}
		
		Date data1 = new Date();
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM--dd HH:mm:ss");
		String date1Str = simpleDateFormat.format(data1);
		System.out.println("排序前的时间是=" + date1Str);
		
		BubbleSort(arr);

		Date data2 = new Date();
		String date2Str = simpleDateFormat.format(data2);
		System.out.println("排序前的时间是=" + date2Str);
	}
	
public static void BubbleSort(int[] arr){
	int temp = 0; //临时变量
		boolean flag = false; //标识变量，表示是否进行过交换

		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){ //!flag表示flag == false。表示在一趟排序中，以此交换都没有发生过
				break;
			}else{
				flag = false; //如果进行了排序，flag会变为true，这时要重置flag，以便进行下一次排序
			}
		}
	}
}
呆白不白
关注
Java冒泡排序方法
qq_41055688的博客
12-24 1032
冒泡排序是属于最为基础的一种排序，也是最简单的一种排序。 实现思路： 首先创建一个数组 int[] array={80,60,20,40,65,30,10}; 思考怎么让相邻的数进行比较 (进行外内循环进行比较） 判断两个元素的大小，如果前面一个元素大于后面一个元素则进行交换。 public class Bubble { public static void main(String...
Java基础学习——数组（5、数组排序算法：冒泡排序，直接选择排序，反转排序）
weixin_47030183的博客
03-11 278
5、数组排序算法 1、冒泡排序 基本思想： 冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把大的元素移动到数组后面（也就是交换两个元素的位置），这样较小的元素就像气泡一样从底部上升到顶部。 算法实现理念： 冒泡算法由双层循环实现，其中外层循环用于控制排序轮数，一般为要排序的数组长度减1次，因为最后一次循环只剩下一个数组元素，不需要对比，同时数组已经完成排序了。而内层循环主要用于对比数组中每个邻近元素的大小，以确定是否交换位置，对比和交换次数随排序轮数而减少。 算
Java实现冒泡排序
潇洒的菜鸡
11-28 424
Java冒泡排序
Java记录 -36- 冒泡排序
weixin_33951761的博客
09-18 66
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名。冒泡排序算法的运作如下：（从后往前）比较相邻的元素。如果第一个比第二个大...
算法基本排序之冒泡排序
红莲灭的博客
08-09 88
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录简单排序1.Comparable接口冒泡排序排序原理分析实现：时间复杂度分析 简单排序 1.Comparable接口 排序就是在元素之间做比较，而Java提供了一个接口Comparable就是用来定义排序规则的 首先在实体类中实现该接口，并实现compareTo方法： public class Student implements Comparable<Student>{ private int age;
java中的冒泡排序法
apologize的学习之路
08-08 506
1.基本写法 import java.util.Arrays; public class TestBubble { public static void main(String[] args) { int[] arr = {1,4,7,3,0}; for(int j=0;j<arr.length-1;j++){//比较几趟 System.out.println("第 " + (
《Java数据结构和算法》学习笔记(2)——4种简单排序算法
03-14
本文将深入探讨四种简单的排序算法：插入排序、冒泡排序、选择排序。这些算法虽然在复杂度上不如高级排序算法如快速排序或归并排序，但它们提供了基础的排序逻辑，有助于理解更复杂的算法思想。 首先，我们来详细...
算法笔记——快速排序及优化(Java实现）
Jeffery♚的博客
07-22 415
快速排序 快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。 快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。 快速排序又是一种分而治之思想在排序算法上的典型应用。本质上来看，快速
算法笔记——插入排序及优化(Java实现)
Jeffery♚的博客
07-22 330
插入排序 插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够理解。插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。 插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。 1. 算法步骤 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果
排序算法总结——Java实现
m0_38132177的博客
04-05 113
此文章是女少侠本人在学习算法与数据结构过程中各类排序算法的笔记，十分感谢相关优秀博主的代码分享和经验总结，后面会附上参考链接，如有侵权，请联系删除。 导航各类排序算法总结冒泡排序选择排序插入排序希尔排序归并排序快速排序堆排序计数排序桶排序基数排序 各类排序算法总结 废话不多数，直接上图： 冒泡排序 选择排序 插入排序 希尔排序 归并排序 快速排序 堆排序 计数排序 桶排序 基数排序 ...
【Java面试（二)】冒泡排序的实现及优化
最新发布
hihielite的博客
01-29 731
今天我们来学习与排序相关的面试题，首先我们先来学习冒泡排序，那什么是冒泡排序呢，它的关键在于数组中相邻元素进行比较，如果前一个小于后一个，它的位置可以不动，相反，则交换位置，依次两两进行相互比较，直到将数组中最大的元素放在最后的位置，每轮冒泡的结果就是将最大的元素放在数组的最后边，直到数组变为升序数组为止🎈🎈。以上就是我们Java面试过程中冒泡排序的实现以及优化内容,最后，如果有什么错误的话，大家可以私信我📬📬，！！
java-直接选择排序
weixin_30294709的博客
03-17 87
直接选择排序是一种简单的排序方法，它每次从当前待排序的区间中选择出最小的元素，把该元素与该区间的第一个元素交换。 第一次从a[0]~a[n-1]中选取最小值，与a0]交换，第二次从a[1]~a[n-1]中选取最小值，与a[1]交换，....，第i次从a[i-1]~a[n-1]中选取最小值，与a[i-1]交换，.....，第n-1次从a[n-2]~a[n-1]中选取最小值，与a[n-2]交换，总共...
【c++】冒泡排序
孙不坚1208
11-19 2996
原来这就是冒泡排序啊 Bubble Sort 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序” 案例 将 n (n <= 1
Java | 基础算法 - 排序：冒泡排序 代码实现（含详细注释）
日常记录
03-29 1791
Java冒泡排序的基本思想、原理图解、算法步骤、代码实现和算法性能分析
软件测试 | 白盒测试 | 5种覆盖方式
IronBull_Zhang的博客
02-26 2006
一.测试代码 冒泡排序 //冒泡排序从小到大递增 class Bubble { int[] arr={9,8,7,6,5,4,3,2,1,1}; public void swap(int arr[],int a,int b){ int temp=arr[a]; arr[a]=arr[b]; arr[b]=temp; }...
十大经典排序算法最强总结（含JAVA代码实现）
weixin_34370347的博客
03-19 406
最近几天在研究排序算法，看了很多博客，发现网上有的文章中对排序算法解释的并不是很透彻，而且有很多代码都是错误的，例如有的文章中在“桶排序”算法中对每个桶进行排序直接使用了Collection.sort()函数，这样虽然能达到效果，但对于算法研究来讲是不可以的。所以我根据这几天看的文章，整理了一个较为完整的排序算法总结，本文中的所有算法均有JAVA实现，经本人调试无误后才发出，如有错误，请各位前...
2021最新java面试题整理
deqing271的博客
03-25 218
算法题： 1、一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在 第10次落地时，共经过多少米？第10次反弹多高？ 程序题： 1、求数组中的最小值 2、将一个数组中元素排序 3、将一个双向链表倒置 面试题： 1、谈谈你做过的项目用到了哪些框架及工作职责 2、谈谈你对springboot的理解 3、谈谈你对springcloud的理解 4、说说redis的哨兵机制 5、说说什么是雪崩 6、Map的实现类有哪些 7、HashMap的底层原理 8、谈谈..
（架构篇+算法篇+大数据）阿里巴巴内部：2020年全技术栈PPT分享
yuandengta的博客
11-05 703
我只截图不说话，PPT大全，氛围研发篇、算法篇、大数据、Java后端架构！除了大家熟悉的交易、支付场景外，支撑起阿里双十一交易1682亿元的“超级工程”其实包括以下但不限于客服、搜索、推荐、广告、库存、物流、云计算等。 Java核心技术栈：覆盖了JVM、锁、并发、Java反射、Spring原理、微服务、Zookeeper、数据库、数据结构等大量知识点。 大数据：Spark、Hadoop 研发篇部分截图一览，感谢大佬们的分享 算法篇部分截...
2021备战金三银四血拼一波算法：字节+百度，java编程教程视频
m0_61364397的博客
11-11 856
======== 一面问了项目，算法题：一个数组里只有0和1，把0换到1前面，不能使用统计次数的方法。扩展：如果有0，1，2三个数咋办？ 二面项目，算法题：无向图的迪杰斯特拉算法实现。 算法血拼：<程序员代码面试指南-IT名企算法与数据结构题目最优解><算法刷题LeetCode><算法-第4版> ======================================================= [算法血拼相关的算法刷题与笔记]等早已整理存放在一个
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值