冒泡排序(Bubble Sort)，是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序。

这里的介绍有简单到复杂(其实不是复杂了，只是进行了简化和规范而已，其实原理基本相同的)。

首先我们来看下面的程序(我在每行程序上都进行了注释，以便于理解。)：

package com.hry.bubble_sort;

import java.util.Arrays;

/**

* @author 侯瑞阳

* java实现冒泡排序算法

*/

public class BubbleSort {

/**

* 定义一个静态的方法方便在主函数中调用

*/

public static void FirstSort(int arr[]) {

// 初始化i为0 因为是数组arr[]是从arr[0]开始的。

int i = 0;

// 输出一句库进行提示

System.out.print("第一趟，第一次排序");

// 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了

if (arr[i] < arr[i + 1]) {

int temp = arr[i];

arr[i] = arr[i + 1];

arr[i + 1] = temp;

}

// 输出排序号之后的结果

System.out.println(Arrays.toString(arr));

}

// 主函数

public static void main(String [] args) {

// 初始化一个数组

int arr[] = {1, 2, 3, 4, 5};

// 调用定义好的静态方法进行排序

FirstSort(arr);

}

}运行程序输出的结果是：

第一趟，第一次排序[2, 1, 3, 4, 5]这样以来，我们是不是就进行了一次简单的比较了呢？那么，1 和 3在进行比较之后，是不是1 和 3 交换位置，输出

[2， 3， 1， 4， 5 ]呢？怎么用程序来实现呢？

如果还不明白的话。我给你一个初始数组是[ 2, 1, 3, 4, 5 ]让你来用程序改成[ 2， 3， 1， 4， 5 ]呢？原来就是上面程序在重复一边呀，那赶紧用 代码来实现下吧！

package com.hry.bubble_sort;

import java.util.Arrays;

/**

* @author 侯瑞阳

* java实现冒泡排序算法

*/

public class BubbleSort {

/**

* 定义一个静态的方法方便在主函数中调用

*/

public static void FirstSort(int arr[]) {

// 初始化i为0 因为是数组arr[]是从arr[0]开始的。

int i = 0;

// 输出一句库进行提示

System.out.print("第一趟，第一次排序");

// 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了

if (arr[i] < arr[i + 1]) {

int temp = arr[i];

arr[i] = arr[i + 1];

arr[i + 1] = temp;

}

// 输出排序号之后的结果

System.out.println(Arrays.toString(arr));

i++;

System.out.print("第一趟，第二次排序");

// 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了

if (arr[i] < arr[i + 1]) {

int temp = arr[i];

arr[i] = arr[i + 1];

arr[i + 1] = temp;

}

// 输出排序号之后的结果

System.out.println(Arrays.toString(arr));

i++;

System.out.print("第一趟，第三次排序");

// 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了

if (arr[i] < arr[i + 1]) {

int temp = arr[i];

arr[i] = arr[i + 1];

arr[i + 1] = temp;

}

// 输出排序号之后的结果

System.out.println(Arrays.toString(arr));

i++;

System.out.print("第一趟，第四次排序");

// 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了

if (arr[i] < arr[i + 1]) {

int temp = arr[i];

arr[i] = arr[i + 1];

arr[i + 1] = temp;

}

// 输出排序号之后的结果

System.out.println(Arrays.toString(arr));

i++;

}

// 主函数

public static void main(String [] args) {

// 初始化一个数组

int arr[] = {1, 2, 3, 4, 5};

// 调用定义好的静态方法进行排序

FirstSort(arr);

}

}我想有一小部分人估计忘记了在刚开始定义的 i 的变量。可不要忘记在每次执行完毕之后不要忘记把 i自身加上1 参与下一次运算呀！来看运行结果：

第一趟，第 1 次排序[2, 1, 3, 4, 5]

第一趟，第 2 次排序[2, 3, 1, 4, 5]

第一趟，第 3 次排序[2, 3, 4, 1, 5]

第一趟，第 4 次排序[2, 3, 4, 5, 1]

好了，通过上面的代码我们简单找出了最小值 并放在了数组最后一个位置。那大家有没有发现其实是有很多代码是重复的呢？聪明的人已经想到了解决办法。既然重复，那么我定义一个循环不就解决了吗。下面来看实现代码：

package com.hry.bubble_sort;

import java.util.Arrays;

/**

* @author 侯瑞阳

* java实现冒泡排序算法

*/

public class BubbleSort {

/**

* 定义一个静态的方法方便在主函数中调用

*/

public static void FirstSort(int arr[]) {

// 因为通过之前发现五个数重复执行了四次，所以定义一个整形来控制for循环的次数

int length = arr.length - 1;

for (int i = 0; i < length; i++) {

// 输出一句库进行提示

System.out.print("第一趟，第一次排序");

// 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了

if (arr[i] < arr[i + 1]) {

int temp = arr[i];

arr[i] = arr[i + 1];

arr[i + 1] = temp;

}

// 输出排序号之后的结果

System.out.println(Arrays.toString(arr));

}

}

// 主函数

public static void main(String [] args) {

// 初始化一个数组

int arr[] = {1, 2, 3, 4, 5};

// 调用定义好的静态方法进行排序

FirstSort(arr);

}

}运行结果：

第一趟，第 1 次排序[2, 1, 3, 4, 5]

第一趟，第 2 次排序[2, 3, 1, 4, 5]

第一趟，第 3 次排序[2, 3, 4, 1, 5]

第一趟，第 4 次排序[2, 3, 4, 5, 1]

有没有发现和之前的一样呢？但是代码是不是减少了很多呢？那么是不是第二趟第三趟第四趟也可以按照这个来实现呢？下面来看实现代码：

package com.hry.bubble_sort;

import java.util.Arrays;

/**

* @author 侯瑞阳

* java实现冒泡排序算法

*/

public class BubbleSort {

/**

* 定义一个静态的方法方便在主函数中调用

*/

public static void FirstSort(int arr[]) {

// 因为通过之前发现五个数重复执行了四次，所以定义一个整形来控制for循环的次数

int length = arr.length - 1;

for (int i = 0; i < length; i++) {

// 输出一句库进行提示

System.out.print("第一趟，第 "+ ( i + 1 ) +" 次排序");

// 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了

if (arr[i] < arr[i + 1]) {

int temp = arr[i];

arr[i] = arr[i + 1];

arr[i + 1] = temp;

}

// 输出排序号之后的结果

System.out.println(Arrays.toString(arr));

}

System.out.println("==============分割线==============");

for (int i = 0; i < length; i++) {

// 输出一句库进行提示

System.out.print("第二趟，第 "+ ( i + 1 ) +" 次排序");

// 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了

if (arr[i] < arr[i + 1]) {

int temp = arr[i];

arr[i] = arr[i + 1];

arr[i + 1] = temp;

}

// 输出排序号之后的结果

System.out.println(Arrays.toString(arr));

}

System.out.println("==============分割线==============");

for (int i = 0; i < length; i++) {

// 输出一句库进行提示

System.out.print("第三趟，第 "+ ( i + 1 ) +" 次排序");

// 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了

if (arr[i] < arr[i + 1]) {

int temp = arr[i];

arr[i] = arr[i + 1];

arr[i + 1] = temp;

}

// 输出排序号之后的结果

System.out.println(Arrays.toString(arr));

}

System.out.println("==============分割线==============");

for (int i = 0; i < length; i++) {

// 输出一句库进行提示

System.out.print("第四趟，第 "+ ( i + 1 ) +" 次排序");

// 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了

if (arr[i] < arr[i + 1]) {

int temp = arr[i];

arr[i] = arr[i + 1];

arr[i + 1] = temp;

}

// 输出排序号之后的结果

System.out.println(Arrays.toString(arr));

}

}

// 主函数

public static void main(String [] args) {

// 初始化一个数组

int arr[] = {1, 2, 3, 4, 5};

// 调用定义好的静态方法进行排序

FirstSort(arr);

}

}

来看运行结果：

第一趟，第 1 次排序[2, 1, 3, 4, 5]

第一趟，第 2 次排序[2, 3, 1, 4, 5]

第一趟，第 3 次排序[2, 3, 4, 1, 5]

第一趟，第 4 次排序[2, 3, 4, 5, 1]

==============分割线==============

第二趟，第 1 次排序[3, 2, 4, 5, 1]

第二趟，第 2 次排序[3, 4, 2, 5, 1]

第二趟，第 3 次排序[3, 4, 5, 2, 1]

第二趟，第 4 次排序[3, 4, 5, 2, 1]

==============分割线==============

第三趟，第 1 次排序[4, 3, 5, 2, 1]

第三趟，第 2 次排序[4, 5, 3, 2, 1]

第三趟，第 3 次排序[4, 5, 3, 2, 1]

第三趟，第 4 次排序[4, 5, 3, 2, 1]

==============分割线==============

第四趟，第 1 次排序[5, 4, 3, 2, 1]

第四趟，第 2 次排序[5, 4, 3, 2, 1]

第四趟，第 3 次排序[5, 4, 3, 2, 1]

第四趟，第 4 次排序[5, 4, 3, 2, 1]

经过四次排序最终一个简单的冒泡排序就完成了。那么细心的同学已经发现了，还是重复了了三次，是不是也可以用循环呢？当然是可以的，下面看代码：

package com.hry.bubble_sort;

import java.util.Arrays;

/**

* @author 侯瑞阳

* java实现冒泡排序算法

*/

public class BubbleSort {

/**

* 定义一个静态的方法方便在主函数中调用

*/

public static void FirstSort(int arr[]) {

int length = arr.length - 1;

for(int j = 0; j < length; j++) {

// 因为通过之前发现五个数重复执行了四次，所以定义一个整形来控制for循环的次数

for (int i = 0; i < length; i++) {

// 输出一句库进行提示

System.out.print("第" + (j + 1 ) + "趟，第 "+ ( i + 1 ) +" 次排序");

// 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了

if (arr[i] < arr[i + 1]) {

int temp = arr[i];

arr[i] = arr[i + 1];

arr[i + 1] = temp;

}

// 输出排序号之后的结果

System.out.println(Arrays.toString(arr));

}

System.out.println("==============分割线==============");

}

}

// 主函数

public static void main(String [] args) {

// 初始化一个数组

int arr[] = {1, 2, 3, 4, 5};

// 调用定义好的静态方法进行排序

FirstSort(arr);

}

}

实现结果：

第1趟，第 1 次排序[2, 1, 3, 4, 5]

第1趟，第 2 次排序[2, 3, 1, 4, 5]

第1趟，第 3 次排序[2, 3, 4, 1, 5]

第1趟，第 4 次排序[2, 3, 4, 5, 1]

==============分割线==============

第2趟，第 1 次排序[3, 2, 4, 5, 1]

第2趟，第 2 次排序[3, 4, 2, 5, 1]

第2趟，第 3 次排序[3, 4, 5, 2, 1]

第2趟，第 4 次排序[3, 4, 5, 2, 1]

==============分割线==============

第3趟，第 1 次排序[4, 3, 5, 2, 1]

第3趟，第 2 次排序[4, 5, 3, 2, 1]

第3趟，第 3 次排序[4, 5, 3, 2, 1]

第3趟，第 4 次排序[4, 5, 3, 2, 1]

==============分割线==============

第4趟，第 1 次排序[5, 4, 3, 2, 1]

第4趟，第 2 次排序[5, 4, 3, 2, 1]

第4趟，第 3 次排序[5, 4, 3, 2, 1]

第4趟，第 4 次排序[5, 4, 3, 2, 1]

==============分割线==============

到此就结束了吗？显然更加细心爱钻研的小伙伴就会发现在“第四趟的第一次排序” 之后结果就已经出来了，后面的不就重复了吗？我为发现这个问题的小伙伴点个赞。那么就会有下面的第二个版本，代码如下：

package com.hry.bubble_sort;

import java.util.Arrays;

/**

* @author 侯瑞阳

* java实现冒泡排序算法

*/

public class BubbleSort {

/**

* 定义一个静态的方法方便在主函数中调用

*/

public static void FirstSort(int arr[]) {

int length = arr.length - 1;

for(int j = 0; j < length; j++) {

// 因为通过之前发现五个数重复执行了四次，所以定义一个整形来控制for循环的次数

// 由于之前的代码存在问题，其解决办法就是在比较次数上做手脚。

for (int i = 0; i < arr.length - 1 - j; i++) {

// 输出一句库进行提示

System.out.print("第" + (j + 1 ) + "趟，第 "+ ( i + 1 ) +" 次排序");

// 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了

if (arr[i] < arr[i + 1]) {

int temp = arr[i];

arr[i] = arr[i + 1];

arr[i + 1] = temp;

}

// 输出排序号之后的结果

System.out.println(Arrays.toString(arr));

}

System.out.println("==============分割线==============");

}

}

// 主函数

public static void main(String [] args) {

// 初始化一个数组

int arr[] = {1, 2, 3, 4, 5};

// 调用定义好的静态方法进行排序

FirstSort(arr);

}

}

运行结果：

第1趟，第 1 次排序[2, 1, 3, 4, 5]

第1趟，第 2 次排序[2, 3, 1, 4, 5]

第1趟，第 3 次排序[2, 3, 4, 1, 5]

第1趟，第 4 次排序[2, 3, 4, 5, 1]

==============分割线==============

第2趟，第 1 次排序[3, 2, 4, 5, 1]

第2趟，第 2 次排序[3, 4, 2, 5, 1]

第2趟，第 3 次排序[3, 4, 5, 2, 1]

==============分割线==============

第3趟，第 1 次排序[4, 3, 5, 2, 1]

第3趟，第 2 次排序[4, 5, 3, 2, 1]

==============分割线==============

第4趟，第 1 次排序[5, 4, 3, 2, 1]

==============分割线==============

这样是不是也能够得出结果，而且比较简单呢？那么这样就结束了吗？显然不是，如果我们排序一次之后就已经得到了我们想要的顺序那么后面的是不是就不用进行了呢？我们来看下面程序帮助我们更好理解：

package com.hry.bubble_sort;

import java.util.Arrays;

/**

* @author 侯瑞阳

* java实现冒泡排序算法

*/

public class BubbleSort {

/**

* 定义一个静态的方法方便在主函数中调用

*/

public static void FirstSort(int arr[]) {

int length = arr.length - 1;

for (int j = 0; j < length; j++) {

// 因为通过之前发现五个数重复执行了四次，所以定义一个整形来控制for循环的次数

// 由于之前的代码存在问题，其解决办法就是在比较次数上做手脚。

for (int i = 0; i < arr.length - 1 - j; i++) {

// 输出一句库进行提示

System.out.print("第" + (j + 1) + "趟，第 " + (i + 1) + " 次排序");

// 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了

if (arr[i] < arr[i + 1]) {

int temp = arr[i];

arr[i] = arr[i + 1];

arr[i + 1] = temp;

}

// 输出排序号之后的结果

System.out.println(Arrays.toString(arr));

}

}

}

public static void FinalSort(int arr[]) {

int length = arr.length - 1;

boolean bool = true;

for (int j = 0; j < length; j++) {

// 因为通过之前发现五个数重复执行了四次，所以定义一个整形来控制for循环的次数

// 由于之前的代码存在问题，其解决办法就是在比较次数上做手脚。

for (int i = 0; i < arr.length - 1 - j; i++) {

// 输出一句库进行提示

System.out.print("第" + (j + 1) + "趟，第 " + (i + 1) + " 次排序");

// 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了

if (arr[i] < arr[i + 1]) {

int temp = arr[i];

arr[i] = arr[i + 1];

arr[i + 1] = temp;

bool = false;

}

// 输出排序号之后的结果

System.out.println(Arrays.toString(arr));

}

if (bool) {

break;

}

}

}

// 主函数

public static void main(String [] args) {

int arr[] = {7, 4, 2, 1};

FirstSort(arr);

System.out.println("==============分割线==============");

arr = new int[]{7, 4, 2, 1};

FinalSort(arr);

}

}

运行结果：

第1趟，第 1 次排序[7, 4, 2, 1]

第1趟，第 2 次排序[7, 4, 2, 1]

第1趟，第 3 次排序[7, 4, 2, 1]

第2趟，第 1 次排序[7, 4, 2, 1]

第2趟，第 2 次排序[7, 4, 2, 1]

第3趟，第 1 次排序[7, 4, 2, 1]

==============分割线==============

第1趟，第 1 次排序[7, 4, 2, 1]

第1趟，第 2 次排序[7, 4, 2, 1]

第1趟，第 3 次排序[7, 4, 2, 1]

虽然最后也进行了三趟但是第二种方法显然比第一种还要简单。

java 排序算法 讲解_java实现排序算法之冒泡排序法详细讲解相关推荐

  1. 无限纷争如何找到以前的服务器,无限纷争远古遗迹及幻境冒险玩法详细讲解

    无限纷争远古遗迹及幻境冒险玩法详细讲解.玩过无限纷争的小伙伴都知道,无限纷争共有六大玩法,勇者之路和暗影裂缝已经和大家讲解过了,几天带来的是无限纷争远古遗迹及幻境冒险玩法详细讲解,希望对大家有所帮助. ...

  2. java数据结构排序实验报告_java数据结构与算法之插入排序详解

    本文实例讲述了java数据结构与算法之插入排序.分享给大家供大家参考,具体如下: 复习之余,就将数据结构中关于排序的这块知识点整理了一下,写下来是想与更多的人分享,最关键的是做一备份,为方便以后查阅. ...

  3. java冒泡遍历对象_Java经典排序算法（冒泡、选择、插入）

    排序算法说明 排序说明 对一序列对象根据某个关键字进行排序. 术语说明 稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面: 不稳定:如果a原本在b的前面,而a=b,排序之后a可能会出现在b ...

  4. java快排原理_Java数据结构与算法——快速排序

    声明:码字不易,转载请注明出处,欢迎文章下方讨论交流. 前言:Java数据结构与算法专题会不定时更新,欢迎各位读者监督.本篇文章介绍排序算法中最常用也是面试中最容易考到的排序算法--快排,包括快排的思 ...

  5. java排序 面试题_Java八大排序（面试答题！）

    八大排序(重点!!) ​排序算法大体可分为两种: 1.比较排序,时间复杂度O(nlogn) ~ O(n^2),主要有:冒泡排序,选择排序,插入排序,归并排序,堆排序,快速排序等. 2.非比较排序,时间 ...

  6. java的算法库_java – 如何实现算法库？

    我有一组用 Java实现的算法并打包为jar文件.该算法适用于第三方访问它们.算法有几种变化.将添加加班,新版本和新类型的算法.与此同时,我不会强迫所有第三方使用新算法. 我正在考虑为此实现一个简单的 ...

  7. c语言冒泡排序法代码(c语言冒泡排序法代码讲解)

    求一个C语言冒泡排序法的简单程序怎么办? 下一趟排序开始时,R[1..lastExchange-1]是有序区,R[lastExchange..n]是无序区.这样,一趟排序可能使当前有序区扩充多个记录, ...

  8. JAVA中希尔排序去的讲解_java 中基本算法之希尔排序的实例详解

    java 中基本算法之希尔排序的实例详解 希尔排序(Shell Sort)是插入排序的一种.也称缩小增量排序,是直接插入排序算法的一种更高效的改进版本.希尔排序是非稳定排序算法.该方法因DL．Shel ...

  9. java string逆序_java经典入门算法题，java初学者必备

    java经典入门算法题 开头求关注警告 喜欢这样文章的可以关注我,我会持续更新,你们的关注是我更新的动力!需要更多java学习资 料的也可以私信我! 祝关注我的人都:身体健康,财源广进,福如东海,寿比 ...

最新文章

  1. ANDROID_MARS学习笔记_S01_011ProgressBar
  2. 小型电商服务器平台搭建（一）
  3. python3.5安装-linux安装python3.5.1
  4. MySQL中数据库的操作
  5. requirejs配置问题
  6. LeetCode每日一题 977. 有序数组的平方
  7. 对于下一代互联网的畅想
  8. 【牛客 - 330I】Applese 的回文串（结论题，类似编辑距离，dp）
  9. ARM Cotex-M4数据手册4---System Control
  10. jquery 提交数据
  11. Windows+Python3.7下自动生成requirements.txt文件
  12. 【t092】迷之阶梯
  13. html制作相册影集,影集相册制作系统
  14. ubuntu下载linux源码
  15. 百度地图封装实现拉框效果
  16. android 全屏FullScreen的配置
  17. Gradle version 和 Android Plugin Version是什么东东，有啥关系
  18. 网上流传房地产崩盘时间表 楼市重蹈日本覆辙 - 新闻中心 - 搜狐焦点网
  19. 全新版windows terminal 更换背景
  20. 4K60帧！RayLink远程控制软件如何帮助设计师远程办公？

热门文章

  1. 使用VB.NET加快代码开发速度
  2. view5.3登录桌面提示当前可用桌面资源不足
  3. 破解CentOS的root密码（救援模式无密码）
  4. jquery兼容IE和火狐下focus()事件
  5. 分布式平台下的HS（High-Security） --Apache Shiro API(介绍)
  6. 控制台打印汉字的方法
  7. iOS11、iPhone X、Xcode9 适配指南
  8. 用Servlet获取表单数据
  9. Codeforces 396A 数论，组合数学
  10. 必读的 Java 学习资料分享！