冒泡排序算法，java

原理：比較兩個相鄰的元素，將值大的元素交換至右端。

在安圖等地區(qū)，都構(gòu)建了全面的區(qū)域性戰(zhàn)略布局，加強發(fā)展的系統(tǒng)性、市場前瞻性、產(chǎn)品創(chuàng)新能力，以專注、極致的服務(wù)理念，為客戶提供成都網(wǎng)站建設(shè)、網(wǎng)站建設(shè) 網(wǎng)站設(shè)計制作按需求定制制作,公司網(wǎng)站建設(shè),企業(yè)網(wǎng)站建設(shè),品牌網(wǎng)站建設(shè),營銷型網(wǎng)站建設(shè),成都外貿(mào)網(wǎng)站建設(shè)公司,安圖網(wǎng)站建設(shè)費用合理。

思路：依次比較相鄰的兩個數(shù)，將小數(shù)放在前面，大數(shù)放在后面。即在第一趟：首先比較第

1個和第2個數(shù)，將小數(shù)放前，大數(shù)放后。然后比較第2個數(shù)和第3個數(shù)，將小數(shù)放前，大

數(shù)放后，如此繼續(xù)，直至比較最后兩個數(shù)，將小數(shù)放前，大數(shù)放后。重復(fù)第一趟步驟，直至

全部排序完成。

publicclass BubbleSort {

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

for(int n:arr){

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

}

for(int i=0;iarr.length-1;i++){//外層循環(huán)控制排序趟數(shù)

for(int j=0;jarr.length-1-i;j++){//內(nèi)層循環(huán)控制每一趟排序多少次 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("原始數(shù)據(jù)為： "); //遍歷數(shù)組

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用于數(shù)組元素交換

int temp; //i記錄掃描次數(shù)

for(int i = data.length - 1; i 0; i--) { //進(jìn)行這一輪的冒泡排序

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("排序結(jié)果為： "); //輸出排序后的結(jié)果

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

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

}

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

}

}

求JAVA冒泡排序法的代碼

你好！很高興能幫到你。

由于你剛學(xué)Java，所以一些編程規(guī)范是需要注意的，而我提供給你的答案看起來雖然有點復(fù)雜，不過采用了面向?qū)ο蟮木幊趟枷耄M量做到低耦合高內(nèi)聚，同時冒泡算法也做了升級，為冒泡的高級快速排序算法，不過為了對比，也保存了傳統(tǒng)的冒泡算法。

需要講解一下，算法本身不難，難在如何做到編程規(guī)范、以及方便修改、易于修改、使得程序靈活、低耦合高內(nèi)聚。

算法部分請看Bubble類，里面有兩種算法，有注釋。

主類為TestBubble，主要用于調(diào)用Bubble對象運行算法、StuInfo對象提供學(xué)生作者信息、Info對象提供運行過程中提示信息。

運行結(jié)果如下（Bubble類為核心算法類）：

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

run：

請輸入您將要輸入整數(shù)的個數(shù)：

10

請輸入一串?dāng)?shù)字進(jìn)行冒泡排序，注意：每次只輸入一個，輸完則回車

1:10

2:23

3:11

4:56

5:45

6:26

7:59

8:28

9:84

10:79

初始序列的數(shù)組為：

10 23 11 56 45 26 59 28 84 79

學(xué)號：200815009* 班級:08軟件3班 姓名：葉科良

排序好的數(shù)組為：

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();

}

/**

* 構(gòu)造方法

* 調(diào)用初始化學(xué)生數(shù)據(jù)、接收命令行整數(shù)、展示結(jié)果3個成員方法

*/

public TestBubble() {

initMemb();

initData();

runBubble();

showResult(this.getIntArray());

}

/**

* 初始化學(xué)生數(shù)據(jù)

*/

private void initData() {

stuInfo.setStuNum("200815009*");

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

stuInfo.setStuName("葉科良");

info.setInputIntNumInfo("請輸入您將要輸入整數(shù)的個數(shù)：");

info.setInputIntInfo("請輸入一串?dāng)?shù)字進(jìn)行冒泡排序，注意：每次只輸入一個，輸完則回車");

info.setShowInputInfo("初始序列的數(shù)組為：");

info.setShowResultInfo("排序好的數(shù)組為：");

info.setInputErrorInfo("對不起，輸入有誤！請輸入整數(shù).");

}

/**

* 接收命令行整數(shù)，使用冒泡算法

*/

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());

}

}

/**

* 展示結(jié)果

*/

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;//輸入整數(shù)個數(shù)

/**

* 從命令行中讀取需要輸入的整數(shù)個數(shù)

* @return 需要輸入的整數(shù)個數(shù)

*/

public int getArraySize() {

Scanner reader1 = new Scanner(System.in);

num = reader1.nextInt();

return num;

}

/**

* 指定數(shù)組大小，從命令行接收整數(shù)

* @param arraySize 數(shù)組大小

* @return 原始整數(shù)數(shù)組

*/

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;

}

/**

* 打印原始輸入數(shù)據(jù)

* @param intArray

*/

public void showAcceptAsIntArray(int[] intArray){

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

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

}

}

/**

* 取得數(shù)組大小

* @return

*/

public int getNum() {

return num;

}

}

class Bubble {

/**

* 給定一個數(shù)組，使用冒泡算法進(jìn)行排序

* @param acceptArray 給定的一個數(shù)組

* @return 排序好的數(shù)組

*/

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

int i, temp;

for (i = 0; i (acceptArray.length - 1); i++) {//兩兩進(jìn)行比較，符合條件的進(jìn)行交換

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

temp = acceptArray[i];

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

acceptArray[i + 1] = temp;

}

}

return acceptArray;

}

/**

* 快速冒泡排序算法

* @param r 輸入的整數(shù)數(shù)組

* @param first 數(shù)組第一個下標(biāo)

* @param end 數(shù)組最后一個下標(biāo)

* @return 排好序的整數(shù)數(shù)組

*/

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) { //利用遞歸反復(fù)劃分

if (first end) {

int pivot = partition(r, first, end); //調(diào)用劃分函數(shù)

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;//提示用戶輸入整數(shù)個數(shù)的消息語句

private String inputIntInfo;//提示用戶輸入整數(shù)的消息語句

private String showInputInfo;//提示顯示用戶輸入整數(shù)的消息語句

private String inputErrorInfo;//提示用戶輸入有誤消息語句

private String showResultInfo;//提示顯示排序結(jié)果

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;//學(xué)生學(xué)號

private String stuName;//學(xué)生姓名

private String stuClass;//學(xué)生班級

@Override

public String toString() {

return "學(xué)號：" + 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 {

/** * 實現(xiàn)冒泡程序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("排序前的數(shù)組各個值:");

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("排序后的數(shù)組各個值:");

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

{

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

}

}

}

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

/** * 實現(xiàn)冒泡程序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("排序前的數(shù)組各個值:");

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

{

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

}

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

swap(numb);

System.out.println("數(shù)組排序后:"); 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 {

/** * 實現(xiàn)冒泡程序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("排序前的數(shù)組各個值:");

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

{

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

}

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

swap(numb);

System.out.println("數(shù)組排序后:"); 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）是一種簡單的排序算法。它重復(fù)地走訪過要排序的數(shù)列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數(shù)列的工作是重復(fù)地進(jìn)行直到?jīng)]有再需要交換，也就是說該數(shù)列已經(jīng)排序完成。這個算法的名字由來是因為越小的元素會經(jīng)由交換慢慢“浮”到數(shù)列的頂端。

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

比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。

對每一對相鄰元素作同樣的工作，從開始第一對到結(jié)尾的最后一對。在這一點，最后的元素應(yīng)該會是最大的數(shù)。

針對所有的元素重復(fù)以上的步驟，除了最后一個。

持續(xù)每次對越來越少的元素重復(fù)上面的步驟，直到?jīng)]有任何一對數(shù)字需要比較。

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++){????//對當(dāng)前無序區(qū)間score[0......length-i-1]進(jìn)行排序(j的范圍很關(guān)鍵，這個范圍是在逐步縮小的)??

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

int?temp?=?score[j];??

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

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

}??

}??????????????

System.out.print("第"?+?(i?+?1)?+?"次排序結(jié)果：");??

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

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

}??

System.out.println("");??

}??

System.out.print("最終排序結(jié)果：");??

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

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

}??

}??

}

各位大神！！！求JAVA簡單的冒泡排序法的代碼解析。小生在此膜拜！！！

/*

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

冒泡排序:

每一輪選擇兩個相鄰數(shù)據(jù)進(jìn)行比較，滿足條件交換位置，每一輪確定一個數(shù)的最終位置（這里我們假設(shè)從小到大排，那么每輪就是確定最大一個數(shù)的位置）

*/

public static void maoPao(int []arr)

{

//外層循環(huán)，控制比較的輪數(shù)。arr.length-1:比較的輪數(shù)永遠(yuǎn)比數(shù)組的長度少1（例如，3個數(shù)我們比較兩次就能知道最大值是誰，4個數(shù)比較3次，5個四次，以此類推）

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

? ?{

//內(nèi)層循環(huán)控制每一輪比較的次數(shù)。arr.length-1-i:下一輪比較次數(shù)比上一輪少1（通過分析我們不難得出，第一輪比較arr.length-1次（此時i=0），第二輪比較arr.length-1-1（此時i=1）,一次類推，每輪減少比較的次數(shù)正好就是i的值，所以內(nèi)層循環(huán)比較次數(shù)為arr.length-1-i）

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

{

? ?//相鄰的兩個元素進(jìn)行比較，滿足條件交換位置

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

{

int temp = arr[j];

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

arr[j+1] = temp;

}

}

??}

}

/*

下邊是一張比較圖，對數(shù)組[34,456,67,78,34,23,67]進(jìn)行冒泡排序

第一輪，通過比較，相鄰交換，我們確定了最大值456的位置，那么第二輪456就不用再參與比較了；

以此類推，最后一輪正好比較第一個和第二個的位置，這樣就最終確定了整個數(shù)組元素的大小順序。

而這個比較過程就像在水中放一堆小球，越重的就越靠近水底，越輕的就越靠近水面一樣，整個過程交換并排序的過程就像是水中的氣泡從底向上溢的過程，所以稱作冒泡排序。

最后，總結(jié)一點，所有涉及for循環(huán)排序的題目，都記住一句話：外層循環(huán)控制比較輪數(shù)（所有元素比較一遍，稱為一輪），內(nèi)層循環(huán)控每輪比較的次數(shù)。我們所要做的就是建立好外層循環(huán)和內(nèi)層循環(huán)之間的關(guān)系（就像這里的i一樣，內(nèi)外層循環(huán)共用了，但它在內(nèi)外層循環(huán)的作用是不一樣的）