冒泡排序算法，java

原理：比较两个相邻的元素，将值大的元素交换至右端。

在安图等地区，都构建了全面的区域性战略布局，加强发展的系统性、市场前瞻性、产品创新能力，以专注、极致的服务理念，为客户提供成都网站建设、网站建设 网站设计制作按需求定制制作,公司网站建设,企业网站建设,品牌网站建设,营销型网站建设,成都外贸网站建设公司,安图网站建设费用合理。

思路：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第

1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大

数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复第一趟步骤，直至

全部排序完成。

publicclass BubbleSort {

publicstaticvoid main(String[] args) { int[] arr={12,45,23,67,56,34,99,123}; System.out.println("排序前数组为：");

for(int n:arr){

System.out.print(n+"");

}

for(int i=0;iarr.length-1;i++){//外层循环控制排序趟数

for(int j=0;jarr.length-1-i;j++){//内层循环控制每一趟排序多少次 if(arr[j]arr[j+1]){ int temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp;

}

}

冒泡排序法java

public class Main extends Object {

public static void main(String[]args) { int[] data = {6,5,9,7,2,8};

System.out.println("冒泡排序法： ");

System.out.println("原始数据为： "); //遍历数组

for(int i = 0; i data.length; i++) {

System.out.print(data[i] + " ");

}

System.out.print("\n"); //冒泡排序

bubbleSort(data);

}

public static void bubbleSort(int[]data) { //temp用于数组元素交换

int temp; //i记录扫描次数

for(int i = data.length - 1; i 0; i--) { //进行这一轮的冒泡排序

for(int j = 0; j i; j++) { //从第一个元素开始和下一个比较，比下一个大则交换

if(data[j] data[j + 1]) {

temp = data[j];

data[j] = data[j + 1];

data[j + 1] = temp;

}

}

}

System.out.print("排序结果为： "); //输出排序后的结果

for(int k = 0; k data.length; k++) {

System.out.print(data[k] + " ");

}

System.out.print("\n");

}

}

求JAVA冒泡排序法的代码

你好！很高兴能帮到你。

由于你刚学Java，所以一些编程规范是需要注意的，而我提供给你的答案看起来虽然有点复杂，不过采用了面向对象的编程思想，尽量做到低耦合高内聚，同时冒泡算法也做了升级，为冒泡的高级快速排序算法，不过为了对比，也保存了传统的冒泡算法。

需要讲解一下，算法本身不难，难在如何做到编程规范、以及方便修改、易于修改、使得程序灵活、低耦合高内聚。

算法部分请看Bubble类，里面有两种算法，有注释。

主类为TestBubble，主要用于调用Bubble对象运行算法、StuInfo对象提供学生作者信息、Info对象提供运行过程中提示信息。

运行结果如下（Bubble类为核心算法类）：

************************************

run：

请输入您将要输入整数的个数：

10

请输入一串数字进行冒泡排序，注意：每次只输入一个，输完则回车

1:10

2:23

3:11

4:56

5:45

6:26

7:59

8:28

9:84

10:79

初始序列的数组为：

10 23 11 56 45 26 59 28 84 79

学号：200815009* 班级:08软件3班 姓名：叶科良

排序好的数组为：

10 11 23 26 28 45 56 59 79 84

源代码如下：

***************************************************

package testBubble;

import java.io.Reader;

import java.util.Scanner;

/**

*

* @author yekeliang

*/

public class TestBubble {

private CommandLineBubbleRunner commandLineBubbleRunner;

private int arraySize;

private int[] intArray;

private StuInfo stuInfo;

private Info info;

/**

* 测试方法

* @param args

*/

public static void main(String[] args) {

TestBubble test = new TestBubble();

}

/**

* 构造方法

* 调用初始化学生数据、接收命令行整数、展示结果3个成员方法

*/

public TestBubble() {

initMemb();

initData();

runBubble();

showResult(this.getIntArray());

}

/**

* 初始化学生数据

*/

private void initData() {

stuInfo.setStuNum("200815009*");

stuInfo.setStuClass("08软件3班");

stuInfo.setStuName("叶科良");

info.setInputIntNumInfo("请输入您将要输入整数的个数：");

info.setInputIntInfo("请输入一串数字进行冒泡排序，注意：每次只输入一个，输完则回车");

info.setShowInputInfo("初始序列的数组为：");

info.setShowResultInfo("排序好的数组为：");

info.setInputErrorInfo("对不起，输入有误！请输入整数.");

}

/**

* 接收命令行整数，使用冒泡算法

*/

private void runBubble() {

try{

System.out.println(info.getInputIntNumInfo());

setArraySize(getCommandLineBubbleRunner().getArraySize());

System.out.println(info.getInputIntInfo());

setIntArray(getCommandLineBubbleRunner().getAcceptAsIntArray(getArraySize()));

System.out.println(info.getShowInputInfo());

getCommandLineBubbleRunner().showAcceptAsIntArray(getIntArray());

Bubble.quick(getIntArray());

} catch(java.util.InputMismatchException e) {

System.out.println(info.getInputErrorInfo());

}

}

/**

* 展示结果

*/

private void showResult(int intArray[]) {

System.out.println("\n" + stuInfo.toString());

System.out.println(info.getShowResultInfo());

for (int i = 0; i intArray.length; i++) {

System.out.print(intArray[i] + " ");

}

}

private void initMemb() {

stuInfo = new StuInfo();

info = new Info();

commandLineBubbleRunner = new CommandLineBubbleRunner();

}

public CommandLineBubbleRunner getCommandLineBubbleRunner() {

return commandLineBubbleRunner;

}

public void setCommandLineBubbleRunner(CommandLineBubbleRunner commandLineBubbleRunner) {

this.commandLineBubbleRunner = commandLineBubbleRunner;

}

public int getArraySize() {

return arraySize;

}

public void setArraySize(int arraySize) {

this.arraySize = arraySize;

}

public int[] getIntArray() {

return intArray;

}

public void setIntArray(int[] intArray) {

this.intArray = intArray;

}

private void getStuInfo() {}

}

/**

*

* @author 叶科良

*/

class CommandLineBubbleRunner {

public int num;//输入整数个数

/**

* 从命令行中读取需要输入的整数个数

* @return 需要输入的整数个数

*/

public int getArraySize() {

Scanner reader1 = new Scanner(System.in);

num = reader1.nextInt();

return num;

}

/**

* 指定数组大小，从命令行接收整数

* @param arraySize 数组大小

* @return 原始整数数组

*/

public int[] getAcceptAsIntArray(int arraySize) {

int[] acceptArray = new int[arraySize];

Scanner reader = new Scanner(System.in);

for (int i = 0; i getNum(); i++) {

System.out.print((i + 1) + ":");

acceptArray[i] = reader.nextInt();

}

return acceptArray;

}

/**

* 打印原始输入数据

* @param intArray

*/

public void showAcceptAsIntArray(int[] intArray){

for (int i = 0; i getNum(); i++) {

System.out.print(intArray[i] + " ");

}

}

/**

* 取得数组大小

* @return

*/

public int getNum() {

return num;

}

}

class Bubble {

/**

* 给定一个数组，使用冒泡算法进行排序

* @param acceptArray 给定的一个数组

* @return 排序好的数组

*/

public static int[] getResultAsIntArray(int[] acceptArray) {

int i, temp;

for (i = 0; i (acceptArray.length - 1); i++) {//两两进行比较，符合条件的进行交换

if (acceptArray[i] acceptArray[i + 1]) {

temp = acceptArray[i];

acceptArray[i] = acceptArray[i + 1];

acceptArray[i + 1] = temp;

}

}

return acceptArray;

}

/**

* 快速冒泡排序算法

* @param r 输入的整数数组

* @param first 数组第一个下标

* @param end 数组最后一个下标

* @return 排好序的整数数组

*/

public static int partition(int[] r, int first, int end) {

int i, j;

i = first;

j = end;

while (i j) {

while (i j r[i] = r[j]) {

j--;

}

if (i j) {

int temp;

temp = r[i];

r[i] = r[j];

r[j] = temp;

}

}

return i;

}

public static void quick(int[] r, int first, int end) { //利用递归反复划分

if (first end) {

int pivot = partition(r, first, end); //调用划分函数

quick(r, first, pivot - 1);

quick(r, pivot + 1, end);

}

}

public static int[] quick(int[] r){

quick(r,0,r.length-1);

return r;

}

}

class Info {

private String inputIntNumInfo;//提示用户输入整数个数的消息语句

private String inputIntInfo;//提示用户输入整数的消息语句

private String showInputInfo;//提示显示用户输入整数的消息语句

private String inputErrorInfo;//提示用户输入有误消息语句

private String showResultInfo;//提示显示排序结果

public String getInputIntNumInfo() {

return inputIntNumInfo;

}

public void setInputIntNumInfo(String inputIntNumInfo) {

this.inputIntNumInfo = inputIntNumInfo;

}

public String getInputIntInfo() {

return inputIntInfo;

}

public void setInputIntInfo(String inputIntInfo) {

this.inputIntInfo = inputIntInfo;

}

public String getShowInputInfo() {

return showInputInfo;

}

public void setShowInputInfo(String showInputInfo) {

this.showInputInfo = showInputInfo;

}

public String getInputErrorInfo() {

return inputErrorInfo;

}

public void setInputErrorInfo(String inputErrorInfo) {

this.inputErrorInfo = inputErrorInfo;

}

public String getShowResultInfo() {

return showResultInfo;

}

public void setShowResultInfo(String showResultInfo) {

this.showResultInfo = showResultInfo;

}

}

class StuInfo {

private String stuNum;//学生学号

private String stuName;//学生姓名

private String stuClass;//学生班级

@Override

public String toString() {

return "学号：" + getStuNum() + " 班级:" + getStuClass() + " 姓名：" + getStuName();

}

public String getStuNum() {

return stuNum;

}

public void setStuNum(String stuNum) {

this.stuNum = stuNum;

}

public String getStuName() {

return stuName;

}

public void setStuName(String stuName) {

this.stuName = stuName;

}

public String getStuClass() {

return stuClass;

}

public void setStuClass(String stuClass) {

this.stuClass = stuClass;

}

}

求冒泡排序的java代码

方法一: package basic.javastu; public class NumberTest {

/** * 实现冒泡程序1 */ public static void main(String[] args) { // TODO Auto-generated method stub

int[] numb=new int[]{3,42,57,1,32,24};

int len=numb.length;

int i,j;

int temp;

System.out.println("排序前的数组各个值:");

for(i=0;ilen;i++)

{

System.out.print(numb[i]+"\t");

}

System.out.println("\n");

for(i=1;i=len;i++)

{

for(j=len-1;j=1;j--)

{

if(numb[j]numb[j-1])

{

temp=numb[j];

numb[j]=numb[j-1];

numb[j-1]=temp;

}

}

}

System.out.println("排序后的数组各个值:");

for(i=0;ilen;i++)

{

System.out.print(numb[i]+"\t");

}

}

}

方法二: package basic.javastu; public class NumberTest2 {

/** * 实现冒泡程序2 */ public static void main(String[] args) { // TODO Auto-generated method stub

int[] numb=new int[]{3,42,57,1,32,24};

int leng=numb.length;

System.out.println("排序前的数组各个值:");

for(int i=0;ileng;i++)

{

System.out.print(numb[i]+"\t");

}

System.out.println("\n");

swap(numb);

System.out.println("数组排序后:"); for(int i=0;ileng;i++)

{

System.out.print(numb[i]+"\t");

} }

private static int[] swap(int[] numb) { int n2[]=numb; int len=n2.length; int i,j; int temp; for(i=1;i=len;i++)

{

for(j=len-1;j=1;j--)

{

if(n2[j]n2[j-1])

{

temp=n2[j];

n2[j]=n2[j-1];

n2[j-1]=temp;

}

}

} return n2; } }

方法三: package basic.javastu; public class NumberTest3 {

/** * 实现冒泡程序2 */ public static void main(String[] args) { // TODO Auto-generated method stub

int[] numb=new int[]{3,42,57,1,32,24};

int leng=numb.length;

System.out.println("排序前的数组各个值:");

for(int i=0;ileng;i++)

{

System.out.print(numb[i]+"\t");

}

System.out.println("\n");

swap(numb);

System.out.println("数组排序后:"); for(int i=0;ileng;i++)

{

System.out.print(numb[i]+"\t");

} }

private static void swap(int[] numb) { int len=numb.length; int i,j; int temp; for(i=1;i=len;i++)

{

for(j=len-1;j=1;j--)

{

if(numb[j]numb[j-1])

{

temp=numb[j];

numb[j]=numb[j-1];

numb[j-1]=temp;

}

}

} } }

java冒泡排序代码

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

冒泡排序算法的运作如下:

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

public class BubbleSort{  

public static void main(String[] args){  

int score[] = {67, 69, 75, 87, 89, 90, 99, 100};  

for (int i = 0; i  score.length -1; i++){    //最多做n-1趟排序  

for(int j = 0 ;j  score.length - i - 1; j++){    //对当前无序区间score[0......length-i-1]进行排序(j的范围很关键，这个范围是在逐步缩小的)  

if(score[j]  score[j + 1]){    //把小的值交换到后面  

int temp = score[j];  

score[j] = score[j + 1];  

score[j + 1] = temp;  

}  

}              

System.out.print("第" + (i + 1) + "次排序结果：");  

for(int a = 0; a  score.length; a++){  

System.out.print(score[a] + "\t");  

}  

System.out.println("");  

}  

System.out.print("最终排序结果：");  

for(int a = 0; a  score.length; a++){  

System.out.print(score[a] + "\t");  

}  

}  

}

各位大神！！！求JAVA简单的冒泡排序法的代码解析。小生在此膜拜！！！

/*

首先我们要先了解冒泡排序的原理！

冒泡排序:

每一轮选择两个相邻数据进行比较，满足条件交换位置，每一轮确定一个数的最终位置（这里我们假设从小到大排，那么每轮就是确定最大一个数的位置）

*/

public static void maoPao(int []arr)

{

//外层循环，控制比较的轮数。arr.length-1:比较的轮数永远比数组的长度少1（例如，3个数我们比较两次就能知道最大值是谁，4个数比较3次，5个四次，以此类推）

for(int i=0;iarr.length-1;i++)

   {

//内层循环控制每一轮比较的次数。arr.length-1-i:下一轮比较次数比上一轮少1（通过分析我们不难得出，第一轮比较arr.length-1次（此时i=0），第二轮比较arr.length-1-1（此时i=1）,一次类推，每轮减少比较的次数正好就是i的值，所以内层循环比较次数为arr.length-1-i）

for(int j=0;jarr.length-1-i;j++)

{

   //相邻的两个元素进行比较，满足条件交换位置

if(arr[j]arr[j+1])

{

int temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

}

}

  }

}

/*

下边是一张比较图，对数组[34,456,67,78,34,23,67]进行冒泡排序

第一轮，通过比较，相邻交换，我们确定了最大值456的位置，那么第二轮456就不用再参与比较了；

以此类推，最后一轮正好比较第一个和第二个的位置，这样就最终确定了整个数组元素的大小顺序。

而这个比较过程就像在水中放一堆小球，越重的就越靠近水底，越轻的就越靠近水面一样，整个过程交换并排序的过程就像是水中的气泡从底向上溢的过程，所以称作冒泡排序。

最后，总结一点，所有涉及for循环排序的题目，都记住一句话：外层循环控制比较轮数（所有元素比较一遍，称为一轮），内层循环控每轮比较的次数。我们所要做的就是建立好外层循环和内层循环之间的关系（就像这里的i一样，内外层循环共用了，但它在内外层循环的作用是不一样的）

分享文章：冒泡算法java代码 冒泡算法c语言程序
链接分享：http://csdahua.cn/article/hpidos.html