java|java 排序算法之冒泡排序
目录
- 基本介绍
- 图解冒泡排序算法的过程
- 代码实现
- 演变过程
- 优化
- 封装算法
- 大量数据耗时测试
基本介绍 【java|java 排序算法之冒泡排序】冒泡排序(Bubble Sorting)(时间复杂度为 O(n2))的基本思想:通过对待排序序列 从前向后(从下标较小的元素开始),依次比较相邻元素的值,若发现逆序则交换,使值较大的元素逐渐从前移向后部,就像水底下的旗袍一样逐渐向上冒。
优化点:因为排序过程中,个元素不断接近自己的位置,如果一趟比较下来没有进行过交换,就说明序列有序,因此要在排序过程中设置一个标志判断元素是否进行过交换。从而减少不必要的比较。(该优化点可以在完成基本的冒泡排序之后再做)
图解冒泡排序算法的过程
![java|java 排序算法之冒泡排序](https://img.it610.com/image/info11/70243140eb60479782724eff2584b4db.jpg)
文章图片
动图:
![java|java 排序算法之冒泡排序](https://img.it610.com/image/info11/e0a2d351b1584ddbb9e9b04aafc8488b.gif)
文章图片
冒泡排序小结:
1.共进行
数组大小 - 1
次大的循环2.每一趟排序的次数在逐渐的减少
3.优化:如果发现在某趟排序中,没有发生一次交换,则可以提前结束冒泡排序。
代码实现
演变过程
为了容易理解,先演示冒泡排序的演变过程
/*** 为了更好的理解,这里把冒泡排序的演变过程演示出来*/@Testpublic void processDemo() {int arr[] = {3, 9, -1, 10, -2}; // 第 1 趟排序:将最大的数排在最后// 总共排序:arr.length - 1int temp = 0; // 临时变量,交换的时候使用for (int i = 0; i < arr.length - 1; i++) {if (arr[i] > arr[i + 1]) {temp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = temp; }}System.out.println("第 1 趟排序后的数组"); System.out.println(Arrays.toString(arr)); // 第 2 趟排序:将第 2 大的数排在倒数第 2 位// 总共排序:arr.length - 1 - 1;// 从头开始排序,其他没有变化,只是将排序次数减少了一次for (int i = 0; i < arr.length - 1 -1; i++) {if (arr[i] > arr[i + 1]) {temp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = temp; }}System.out.println("第 2 趟排序后的数组"); System.out.println(Arrays.toString(arr)); // 第 3 趟排序:将第 3 大的数排在倒数第 3 位// 总共排序:arr.length - 1 - 2;// 从头开始排序,其他没有变化,只是将排序次数减少了 2 次for (int i = 0; i < arr.length - 1 -2; i++) {if (arr[i] > arr[i + 1]) {temp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = temp; }}System.out.println("第 3 趟排序后的数组"); System.out.println(Arrays.toString(arr)); // 第 4 趟排序:将第 4 大的数排在倒数第 4 位// 总共排序:arr.length - 1 - 3;// 从头开始排序,其他没有变化,只是将排序次数减少了 3 次for (int i = 0; i < arr.length - 1 -3; i++) {if (arr[i] > arr[i + 1]) {temp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = temp; }}System.out.println("第 4 趟排序后的数组"); System.out.println(Arrays.toString(arr)); // 第 5 趟没有必要,因为这里有 5 个数字,确定了 4 个数字,剩下的那一个就已经出来了}
测试输出
第 1 趟排序后的数组从上述的 4 趟排序过程来看,循环体都是一样的,只是每次循环的次数在减少,那么就可以如下简化
[3, -1, 9, -2, 10]
第 2 趟排序后的数组
[-1, 3, -2, 9, 10]
第 3 趟排序后的数组
[-1, -2, 3, 9, 10]
第 4 趟排序后的数组
[-2, -1, 3, 9, 10]
@Testpublic void processDemo2() {int arr[] = {3, 9, -1, 10, -2}; // 总共排序:arr.length - 1int temp = 0; // 临时变量,交换的时候使用for (int j = 0; j < arr.length - 1; j++) {for (int i = 0; i < arr.length - 1 - j; i++) {if (arr[i] > arr[i + 1]) {temp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = temp; }}System.out.println("第 " + (j + 1) + " 趟排序后的数组"); System.out.println(Arrays.toString(arr)); }}
测试输出
第 1 趟排序后的数组
[3, -1, 9, -2, 10]
第 2 趟排序后的数组
[-1, 3, -2, 9, 10]
第 3 趟排序后的数组
[-1, -2, 3, 9, 10]
第 4 趟排序后的数组
[-2, -1, 3, 9, 10]
优化
对于优化,减少排序次数
@Testpublic void processDemo3() {int arr[] = {3, 9, -1, 10, 20}; // 总共排序:arr.length - 1int temp = 0; // 临时变量,交换的时候使用boolean change = false; // 标识变量,表示是否进行过交换for (int j = 0; j < arr.length - 1; j++) {for (int i = 0; i < arr.length - 1 - j; i++) {if (arr[i] > arr[i + 1]) {temp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = temp; change = true; }}if(!change){// 如果有 1 轮下来,都没有进行排序,则可以提前退出break; }else{change = false; // 重置 change!!!, 进行下次判断}System.out.println("第 " + (j + 1) + " 趟排序后的数组"); System.out.println(Arrays.toString(arr)); }}
测试输出:
第 1 趟排序后的数组这里更改了原始数组,因为优化的点,得看你这个数组原来的排序 和 元素组成,算是一种概率问题,并不是在任何情况下都可以被优化
[3, -1, 9, 10, 20]
第 2 趟排序后的数组
[-1, 3, 9, 10, 20]
封装算法
/*** 把排序算法封装成一个方法,方便被复用** @param arr*/public static void bubbleSort(int[] arr) {// 总共排序:arr.length - 1int temp = 0; // 临时变量,交换的时候使用boolean change = false; for (int j = 0; j < arr.length - 1; j++) {for (int i = 0; i < arr.length - 1 - j; i++) {if (arr[i] > arr[i + 1]) {temp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = temp; change = true; }}if(!change){// 如果有 1 轮下来,都没有进行排序,则可以提前退出break; }else{change = false; // 重置 change!!!, 进行下次判断}}}
测试调用
/*** 测试封装后的算法*/@Testpublic void bubbleSortTest() {int[] arr = {3, 9, -1, 10, 20}; System.out.println("排序前:" + Arrays.toString(arr)); bubbleSort(arr); System.out.println("排序后:" + Arrays.toString(arr)); }
测试输出
排序前:[3, 9, -1, 10, 20]
排序后:[-1, 3, 9, 10, 20]
大量数据耗时测试
排序随机生成的 8 万个数据
/*** 大量数据排序时间测试*/@Testpublic void bulkDataSort() {int max = 80000; int[] arr = new int[max]; for (int i = 0; i < max; i++) {arr[i] = (int) (Math.random() * 80000); }Instant startTime = Instant.now(); bubbleSort(arr); //System.out.println(Arrays.toString(arr)); Instant endTime = Instant.now(); System.out.println("共耗时:" + Duration.between(startTime, endTime).toMillis() + " 毫秒"); }
测试输出
运行几次,差不多在 13 秒左右到此这篇关于java 排序算法之冒泡排序的文章就介绍到这了,更多相关java 冒泡排序内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!
共耗时:14656 毫秒
共耗时:13853 毫秒
推荐阅读
- JAVA(抽象类与接口的区别&重载与重写&内存泄漏)
- 画解算法(1.|画解算法:1. 两数之和)
- 事件代理
- Guava|Guava RateLimiter与限流算法
- Java|Java OpenCV图像处理之SIFT角点检测详解
- java中如何实现重建二叉树
- 数组常用方法一
- 【Hadoop踩雷】Mac下安装Hadoop3以及Java版本问题
- 一个选择排序算法
- SG平滑轨迹算法的原理和实现