java冒泡排序代碼

❶ 冒泡排序如何使用java語言完成

冒泡排序的原理：

從第一個元素開始，將相鄰的兩個元素依次進行比較，直到最後兩個元素完成比較。如果前一個元素比後一個元素大，則交換它們的位置。整個過程完成後最後一個元素就是最大值，完成第一輪比較，後邊通過for循環依次完成後續比較。

運行代碼如下：

package day01;

public class 冒泡 {

public static void main(String[] args) {

int []arr=new int[] {12,45,33,46,3};

System.out.println("排序之前的元素順序:");

for(int i=0;i<arr.length;i++)

{

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

}

int t;

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

{

for(int x=0;x<arr.length-1;x++)

{

if(arr[x]>arr[x+1])

{

t=arr[x];

arr[x]=arr[x+1];

arr[x+1]=t;

}

}

}

System.out.println();

System.out.println("排序之後的元素順序:");

for(int k=0;k<arr.length;k++)

{

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

}

}

}

運行結果截圖：

(1)java冒泡排序代碼擴展閱讀：

（1）冒泡排序每一輪把一個最大的元素放在數組的最後

（2）如果想要實現倒敘比較輸出可以把代碼判斷大小的部分改為下邊代碼即可。

if(arr[x]>arr[x+1])

{

t=arr[x];

arr[x]=arr[x+1];

arr[x+1]=t;

}

（3）使用知識點：數組length的使用，數組的定義，for循環的嵌套。

❷ 求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中編寫冒泡排序演算法 bubbleSort(int[]arr)

/**
*des:冒泡排序演算法的一般性策略：搜索整個值列，比較相鄰元素，如果兩者的相對次序不對，
*則交換它們，其結果是最大值「想水泡一樣」移動到值列的最後一個位置上，
*這也是它在最終完成排序的值列中合適的位置。
*然後再次搜索值列，將第二大的值移動至倒數第二個位置上，重復該過程，直至將所有元素移動到正確的位置上。
*2014-4-9-zbl
**/
publicclassBubbleSort{

/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
Comparable[]a={4,9,23,1,45,27,5,2};
bubbleSort1(a);

Comparable[]b={4,9,23,1,45,27,5,2};
bubbleSort2(b);

int[]c={4,9,23,1,45,27,5,2};
bubbleSort3(c);
}

publicstaticvoidbubbleSort3(int[]data)
{
inttemp;
for(inti=0;i<data.length;i++){
intflag=0;
for(intj=0;j<data.length-i-1;j++){
if(data[j]<data[j+1]){
temp=data[j];
data[j]=data[j+1];
data[j+1]=temp;
flag=1;
}
}
if(flag==0)break;
System.out.print("第"+i+"遍:{");
for(intk=0;k<data.length;k++){
System.out.print(data[k]+",");
}
System.out.println("}");
}
}

publicstaticvoidbubbleSort1(Comparable[]data)
{
Comparabletemp;
for(intposition=data.length-1;position>=0;position--){
intflag=0;
for(intscan=0;scan<position;scan++){
if(data[scan].compareTo(data[scan+1])<0){
temp=data[scan];
data[scan]=data[scan+1];
data[scan+1]=temp;
flag=1;
}
}
if(flag==0){
break;
}
System.out.print("第"+position+"遍:{");
for(inti=0;i<data.length;i++){
System.out.print(data[i]+",");
}
System.out.println("}");
}
}

publicstaticvoidbubbleSort2(Comparable[]data)
{
Comparabletemp;
for(intposition=0;position<data.length-1;position++){
intflag=0;
for(intscan=0;scan<data.length-1-position;scan++){
if(data[scan].compareTo(data[scan+1])<0){
temp=data[scan];
data[scan]=data[scan+1];
data[scan+1]=temp;
flag=1;
}
}
if(flag==0){
break;
}
System.out.print("第"+position+"遍:{");
for(inti=0;i<data.length;i++){
System.out.print(data[i]+",");
}
System.out.println("}");
}
}

}

❹ 冒泡法排序，java代碼 排序1 8 5 2 4 9

publicclassTest{
	publicstaticvoidmain(String[]args){
		int[]a={1,8,5,2,4,9};
		//冒泡排序
		for(intk=0;k<a.length-1;k++){
			for(intj=k+1;j<a.length;j++){//升序把<改成>
				if(a[k]>a[j]){
					inttemp=a[k];
					a[k]=a[j];
					a[j]=temp;
				}
			}
		}
		System.out.println("排序後:");
		for(inti=0;i<a.length;i++){
			System.out.print(a[i]+"");
		}
	}
}

❺ 用java寫個冒泡排序

冒泡排序演算法：

int類型的數組：3 1 6 2 5

第一次循環：

1 3 6 2 5

1 3 6 2 5

1 3 2 6 5

1 3 2 5 6

第二次循環：

1 3 2 5

1 2 3 5

1 2 3 5

第三次循環：

1 2 3

1 2 3

。。。

演算法：取出最大的放在最後，下次就不用比較最後一個了。*/
publicclassBubbleSort{
publicstaticvoidmain(String[]args){
int[]a={3,1,6,2,5};
//開始排序
for(inti=a.length-1;i>0;i--){
for(intj=0;j<i;j++){
if(a[j]>a[j+1]){
//交換位置
inttemp;
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
//遍歷
for(inti=0;i<a.length;i++){
System.out.println(a[i]);
}
}
}

❻ 用java語言用冒泡排序如何寫代碼啊，求大神，求仔細代碼。

純手工，隨意寫的，希望對你有幫助！！
public class MaoPao{
//定義一個整形數組
int[] a = new int[10];
//中間數
int flag = 0;
//g給數組賦值
a = {14,12,21,52,36,78,45,31,33,98};
//判斷
for(int i=0;i<a.length;i++){
for(int j=i+1;i<a.length;i++){
//交換位置，最大的放第一個
if(a[i]<a[j]){
flag = a[i];
a[i] = a[j];
a[j] = a[i];
}
}
}
//輸出數組
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}
}

❼ java實現冒泡排序

你這樣寫，相當於只冒了一次泡，把最大的一個數，也就是最後一個數，找出來了，冒泡排序是要for循環里在嵌套一個for循環才能做出來的，外面的for循環控制冒泡多少次，裡面的循環找出每次的最大值。你這樣寫少了外面的那個for循環，相當於只找了一次最大值。

❽ java冒泡排序

.example-btn{color:#fff;background-color:#5cb85c;border-color:#4cae4c}.example-btn:hover{color:#fff;background-color:#47a447;border-color:#398439}.example-btn:active{background-image:none}div.example{width:98%;color:#000;background-color:#f6f4f0;background-color:#d0e69c;background-color:#dcecb5;background-color:#e5eecc;margin:0 0 5px 0;padding:5px;border:1px solid #d4d4d4;background-image:-webkit-linear-gradient(#fff,#e5eecc 100px);background-image:linear-gradient(#fff,#e5eecc 100px)}div.example_code{line-height:1.4em;width:98%;background-color:#fff;padding:5px;border:1px solid #d4d4d4;font-size:110%;font-family:Menlo,Monaco,Consolas,"Andale Mono","lucida console","Courier New",monospace;word-break:break-all;word-wrap:break-word}div.example_result{background-color:#fff;padding:4px;border:1px solid #d4d4d4;width:98%}div.code{width:98%;border:1px solid #d4d4d4;background-color:#f6f4f0;color:#444;padding:5px;margin:0}div.code div{font-size:110%}div.code div,div.code p,div.example_code p{font-family:"courier new"}pre{margin:15px auto;font:12px/20px Menlo,Monaco,Consolas,"Andale Mono","lucida console","Courier New",monospace;white-space:pre-wrap;word-break:break-all;word-wrap:break-word;border:1px solid #ddd;border-left-width:4px;padding:10px 15px} 排序演算法是《數據結構與演算法》中最基本的演算法之一。排序演算法可以分為內部排序和外部排序，內部排序是數據記錄在內存中進行排序，而外部排序是因排序的數據很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。常見的內部排序演算法有：插入排序、希爾排序、選擇排序、冒泡排序、歸並排序、快速排序、堆排序、基數排序等。以下是冒泡排序演算法：

冒泡排序（Bubble Sort）也是一種簡單直觀的排序演算法。它重復地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個演算法的名字由來是因為越小的元素會經由交換慢慢"浮"到數列的頂端。

作為最簡單的排序演算法之一，冒泡排序給我的感覺就像 Abandon 在單詞書里出現的感覺一樣，每次都在第一頁第一位，所以最熟悉。冒泡排序還有一種優化演算法，就是立一個 flag，當在一趟序列遍歷中元素沒有發生交換，則證明該序列已經有序。但這種改進對於提升性能來
說並沒有什麼太大作用。 1. 演算法步驟
比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。

對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素會是最大的數。

針對所有的元素重復以上的步驟，除了最後一個。

持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。
2. 動圖演示

3. 什麼時候最快
當輸入的數據已經是正序時（都已經是正序了，我還要你冒泡排序有何用啊）。
4. 什麼時候最慢
當輸入的數據是反序時（寫一個 for 循環反序輸出數據不就行了，幹嘛要用你冒泡排序呢，我是閑的嗎）。 5. JavaScript 代碼實現 實例 function bubbleSort ( arr ) {
    var len = arr. length ;
    for ( var i = 0 ; i arr [ j+ 1 ] :
                arr [ j ] , arr [ j + 1 ] = arr [ j + 1 ] , arr [ j ]
    return arr
7. Go 代碼實現 實例 func bubbleSort ( arr [] int ) [] int {
        length := len ( arr )
        for i := 0 ; i < length ; i ++ {
                for j := 0 ; j < length - 1 - i ; j ++ {
                        if arr [ j ] > arr [ j + 1 ] {
                                arr [ j ], arr [ j + 1 ] = arr [ j + 1 ], arr [ j ]
                        }
                }
        }
        return arr
}
8. Java 代碼實現 實例 public class BubbleSort implements IArraySort {

    @Override
    public int [ ] sort ( int [ ] sourceArray ) throws Exception {
        // 對 arr 進行拷貝，不改變參數內容
        int [ ] arr = Arrays . Of ( sourceArray, sourceArray. length ) ;

        for ( int i = 1 ; i

❾ Java冒泡排序

package net.sunyixin.acggo.test;
public class Main{

public static void outputArray(int[] arr){
String arrStr = "";
for(int i : arr){
arrStr += i + " ";
}
System.out.println(arrStr);
}

public static void swap(int[] arr, int i, int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}

/**
* 冒泡排序方法
* @param nums 排序對象
*/
public static void bubbleSort(int[] nums){
for(int i=0;i<nums.length;i++){
for(int j=0;j<nums.length-1-i;j++){
if(nums[j] > nums[j+1]){
swap(nums, j, j+1);
}
}
}
}

public static void main(String[] args){
int[] arr = new int[8];
for(int i=0;i<arr.length;i++){
arr[i] = (int)(Math.random()*100);
}
bubbleSort(arr);
outputArray(arr);
}
}