文档章节

Java中的冒泡排序

o
 osc_a22drz29
发布于 2019/03/25 16:35
字数 2530
阅读 0
收藏 0

精选30+云产品,助力企业轻松上云!>>>

Java中的冒泡排序

排序的第一种思想:将第一个值与后面的值相比较,如果第一个值比其他值小,那么将较大的值与第一个换位置,然后继续比较直至所有的数比较完成。这样就可以保证第一个数是最大数。然后将第二个数再重复进行一遍此操作,不同的是第二个数进行操作时不用与第一个相比,因为已经确定过第一个是最大值。

排序的第二种思想:将两个相邻的数比较(第一个值和第二个值;第二个值和第三个值;第三个值和第四个值……),如果第一个值比第二个值小,那么将这两个值换一个位置,然后后面依次进行此操作,这样可以保证最小值在最后面。

首先冒泡排序的核心思想就是循环赋值,将两个值在条件满足的情况下交换位置。
例如:  3 , 5  如果第一个值小于第二个值则进行交换  →     5 , 3
而在Java中进行换位置的操作我们不能直接交换值,直接交换值的话会将值覆盖
比如说:

 1 package Dome;
 2 
 3 public class Dome1 {
 4     
 5     public static void main(String[] args) {
 6         
 7         int arr[] = { 1, 2, 3, 4, 5 };
 8         
 9         System.out.println(arr[0] + ":" + arr[1]);
10         
11         arr[0] = arr[1]; // 将下标为1的值赋值给下标为0的值
12         
13         arr[1] = arr[0]; // 将下标为0的值赋值给下标为1的值
14         
15         System.out.println(arr[0] + ":" + arr[1]);
16         
17     }
18     
19 }

但是这样交换值的方法是错误的:

因为首先进行
  arr[0] = arr[1];
此时arr[0]已经被修改为2了也就是arr[1]的值;
再将arr[0]的值赋值给arr[1]的话他们的值就是相同的了;

所以交换值正确的做法为:

 1 package Dome;
 2 
 3 public class Dome1 {
 4     
 5     public static void main(String[] args) {
 6         
 7         int arr[] = { 1, 2, 3, 4, 5 };
 8         
 9         System.out.println(arr[0] + ":" + arr[1]);
10         
11         int temp;
12         
13         temp = arr[0];        //将下标为0的值赋值给temp
14         
15         arr[0] = arr[1]; // 将下标为1的值赋值给下标为0的值
16         
17         arr[1] = temp;     // 将下标为0的值赋值给下标为1的值
18         
19         System.out.println(arr[0] + ":" + arr[1]);
20         
21     }
22     
23 }

首先定义一个与数组类型相同的变量temp(名字自定义)来储存数组中的值,先将arr[0]的赋值给temp,然后将arr[1]赋值给arr[0],最后将temp的值赋值给arr[1];通俗的来讲有一桶浑水和一桶干净水,如果想换个水桶装肯定不能直接将浑水往干净的水里面倒,则要另一个桶来装浑水,然后将干净的水倒入装浑水的桶里面,然后再将转移的浑水装入原来的装干净的水的水桶中,所以这里我们就需要多一个桶,也就是变量temp,这个变量的作用就是储存一个数组中的某个值,以便进行交换,避免覆盖 ;

而冒泡的核心操作就是循环进行赋值,直到排序完成;

那么我们接下来进行具体的操作(以数组[1,2,3,4,5]为例):

1.开始我们阐述的第一种排序思想(将第一个值依次与后面的相比):
首先进行第一个值的比较:
  第一个值与第二个值比较满足条件进行交换  :  2,1,3,4,5
  第一个值与第三个值比较满足条件进行交换  :  3,1,2,4,5
  第一个值与第四个值比较满足条件进行交换  :  4,1,2,3,5
  第一个值与第五个值比较满足条件进行交换  :  5,1,2,3,4
  此时第一个值的比较完成,现在数组中第一个值便是数组中的最大值;

开始进行第二个值的比较:
(第二个值不需要与第一个相比因为在第一轮已经比过了)
  第二个值与第三个值比较满足条件进行交换  :  5,2,1,3,4
  第二个值与第四个值比较满足条件进行交换  :  5,3,1,2,4
  第二个值与第五个值比较满足条件进行交换  :  5,4,1,2,3
  此时第二个值的比较完成,现在第二个值为数组中的第二大的值;

开始进行第三个值的比较:
  第三个值与第四个值比较满足条件进行交换  :  5,4,2,1,3
  第三个值与第五个值比较满足条件进行交换  :  5,4,3,1,2
  此时第三个值的比较完成。

开始进行第四个值的比较:
  第四个值与第五个值比较满足条件进行交换  :  5,4,3,2,1
至此排序完成。

然后总结一下规律:
  我们开始比较的值总共有四个(第一个值,第二个值,第三个值,第四个值)也就是数组的长度减1,而被比较的值是从开始比较的值的下标加1开始的然后自增,例如第一个值比较是是从第二个值开始与第一个值比较,第一轮总共比较了4次,第二轮3次,第三轮2次,第四轮1次。

然后找规律:
外层循环 内层循环开始的下标(下标是从0开始所以要减一) 内层循环次数

   1            2-1               4
   2            3-1               3
   3            4-1               2
   4            5-1               1
因为是遍历数组要使用下标,所以要从0开始所以将外层循环的1,2,3,4改为0,1,2,3

代码如下:

 1 package Dome;
 2 
 3 public class Dome1 {
 4     public static void main(String[] args) {
 5         int arr[] = { 1, 2, 3, 4, 5 };
 6         int temp; // 定义一个变量储存数组中的值
 7         int x = 0;// 交换的次数
 8 
 9         // 外层循环的次数为数组长度减1 -->arr.length - 1
10         for (int i = 0; i < arr.length - 1; i++) {
11             /**
12              * 因为是下一个值与前面的值比较所以j的下标为i+1 而j的值会随着i增加第一次为1,第二次为2,第三次为3,第四次为4
13              * 循环的次数为: 4 3 2 1 因为j自增 所以j只需要小于5即数组的长度即可
14              */
15             for (int j = i + 1; j < arr.length; j++) {
16                 if (arr[i] < arr[j]) {
17                     // 进行交换
18                     temp = arr[i];
19                     arr[i] = arr[j];
20                     arr[j] = temp;
21 
22                 }
23                 x++;// 交换的次数自增+1
24                 
25                 // 查看每次操作过后的组数
26                 System.out.print("第" + x + "次交换" + ":\t");
27                 for (int z = 0; z < arr.length; z++) {
28                     System.out.print(arr[z] + " ");
29                 }
30                 System.out.println();
31             }
32         }
33     }
34 }

 

运行的结果

 

发现每次的结果与分析时的一样。由此排序完成

1.开始我们阐述的第一种排序思想(相邻的比较):
首先从第一个值开始比较:
  第一个值与第二个值比较满足条件进行交换  :  2,1,3,4,5
  第二个值与第三个值比较满足条件进行交换  :  2,3,1,4,5
  第三个值与第四个值比较满足条件进行交换  :  2,3,4,1,5
  第四个值与第五个值比较满足条件进行交换  :  2,3,4,5,1
  这种操作核心原理与第一种相同,但是这种操作的结果是将最小的值往后移,第一次操作完的结果会使最后一位为最小值;
进行第二次比较:
  第一个值与第二个值比较满足条件进行交换  :  3,2,4,5,1
  第二个值与第三个值比较满足条件进行交换  :  3,4,2,5,1
  第三个值与第四个值比较满足条件进行交换  :  3,4,5,2,1
  因为确定最后一个数为最小值了所以比较到倒数第二个就可以结束了,此时倒数第二个的值为倒数第二小;
进行第三次比较:
  第一个值与第二个值比较满足条件进行交换  :  4,3,5,2,1
  第二个值与第三个值比较满足条件进行交换  :  4,5,3,2,1
  此时倒数第三个数为倒数第三小;
进行第四次比较:
  第一个值与第二个值比较满足条件进行交换  :  5,4,3,2,1
  此时倒数第四个数为倒数第四小;第一个数为最大;比较完成
然后总结一下规律:
  和第一种相似,外层循环也进行了四次,就是数组的长度减1,内层循环分别进行了4,3,2,1次;不一样的是这次的比较每次都是从第一个第一个值开始(下标对应的为0),但是循环的次数依次减少,所以我们限制循环的次数的条件要变;
找规律:
 外层循环 外层开始的下标 内层开始的下标  内层循环次数
   1      0         0        4
   2      1         0        3
   3      2         0        2
   4      3         0             1
  因为这次排序中外层循环的下标只用于控制外层循环的次数所以可以不用写出来;
代码如下:

 1 package Dome;
 2 
 3 public class Dome1 {
 4     public static void main(String[] args) {
 5         int arr[] = { 1, 2, 3, 4, 5 };
 6         int temp; // 定义一个变量储存数组中的值
 7         int x = 0;// 交换的次数
 8 
 9         // 外层循环的次数为数组长度减1 -->arr.length - 1
10         for (int i = 0; i < arr.length - 1; i++) {
11             /**
12              * 因为是相邻的值比较,所以只用到了j的下标,i的下标只用来控制循环次数
13              * j每自增一次就是往后面移一次相邻的两个数
14              */
15             for (int j = 0; j < arr.length-1-i; j++) {
16                 if (arr[j] < arr[j+1]) {
17                     //进行交换
18                     temp = arr[j];
19                     arr[j] = arr[j+1];
20                     arr[j+1] = temp;
21                 }
22                 x++;// 交换的次数自增+1
23                 
24                 // 查看每次操作过后的组数
25                 System.out.print("第" + x + "次交换" + ":\t");
26                 for (int z = 0; z < arr.length; z++) {
27                     System.out.print(arr[z] + " ");
28                 }
29                 System.out.println();
30             }
31         }
32     }
33 }

 

结果如下:

分析的与结果一致,第二种排序完成;

 

至此完成了两种冒泡排序,如有错误和建议请在评论留言。

                           2019-03-25  16:27:55

o
粉丝 0
博文 500
码字总数 0
作品 0
私信 提问
加载中
请先登录后再评论。
图文并茂结合Java代码理解冒泡排序的原理

概念 什么是冒泡排序,冒泡排序就是比较相邻之间的两个元素,如果前者比后者大,那么就交换这两个元素的位置,一直比较到最后一个元素。然后再重复这样的操作,一直到没有任何一个元素的位置...

Java学习提升
06/09
0
0
【算法】数据结构面试算法题目

1 数组去重 python实现 #调用内置函数去重def func(str):len1=len(str)len2=len(list(set(str)))print("去重后的结果是:",list(set(str)),"t去重个数是:",(len1-len2)) for 循环去重 def ......

伏草惟存
2016/11/04
0
0
Java 排序

Java二分查找法 Java冒泡排序 Java选择排序 Java插入排序 Java希尔排序 Java计数排序 Java快排算法 Java归并排序 Java堆排序 动图演示

GordonDicaprio
04/07
0
0
Java回顾--jdk jre jvm的简单概念和三个常见排序算法

1、JRE、JDK、JVM:   JVM: Java Virtual Machine,Java虚拟机,是Java能够跨平台的核心所在,它只认识 .class文件,且同一段Java代码在编译后生成的.class文件都是一样的,jvm识别.clas...

osc_d8j4rcut
2019/09/06
6
0
java 通配符的应用— java 排序算法

这几天无聊,又重新学起java的排序算法,为DualPivotQuickSort做准备。为了更好地适应各种情况,我们选择使用通用类型T和通配符的上下界来实现,同时这次谈的是对数组对象的排序。如果你对j...

天地一MADAO_
2014/03/02
144
0

没有更多内容

加载失败,请刷新页面

加载更多

浅谈对python pandas中 inplace 参数的理解

这篇文章主要介绍了对python pandas中 inplace 参数的理解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧 pandas 中 inplace 参数在很多函数中都会有,它的作用是:是否...

Linux就该这么学
2分钟前
0
0
C++ 从基本数据类型说起

前言 int 在32位和64位操作系统,都是四个字节长度。为了能编写一个在32位和64位操作系统都能稳定运行的程序,建议采用std::int32_t 或者std::int64_t指定数据类型。*与long随操作系统子长变...

osc_sxdofc9c
2分钟前
0
0
游戏音乐的作用以及起源

游戏音乐是由特殊的音乐、语言符号、美学符号组成,在电子游戏的发展下,游戏音乐越来越成熟,游戏音乐与美术相融合,能够带给玩家视觉与声音的感官冲击,形成游戏音乐所具有的独特的审美效果...

奇亿音乐
3分钟前
0
0
2020,最新Model的设计-APP重构之路

很多的app使用MVC设计模式来将“用户交互”与“数据和逻辑”分开,而model其中一个重要作用就是持久化。下文中设计的Model可能不是一个完美的,扩展性强的model范例,但在我需要重构的app中,...

osc_mfzkzkxi
3分钟前
0
0
面对职业瓶颈,iOS 开发人员应该如何突破?

我们经常看到 iOS 开发人员(各种能力水平都有)的一些问题,咨询有关专业和财务发展方面的建议。 这些问题有一个共同点:前面都会说“我现在遇到了职业困境”,然后会问一些诸如“我是否应该...

osc_gfpedeca
4分钟前
0
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部