java冒泡排序經典代碼

❶ java冒泡排序詳細講解

依次比較相鄰的兩個數，將小數放在前面，大數放在後面。即在第一趟：首先比較第1個和第2個數，將小數放前，大數放後。然後比較第2個數和第3個數，將小數放前，大數放後，如此繼續，直至比較最後兩個數，將小數放前，大數放後。至此第一趟結束，將最大的數放到了最後。在第二趟：仍從第一對數開始比較（因為可能由於第2個數和第3個數的交換，使得第1個數不再小於第2個數），將小數放前，大數放後，一直比較到倒數第二個數（倒數第一的位置上已經是最大的），第二趟結束，在倒數第二的位置上得到一個新的最大數（其實在整個數列中是第二大的數）。如此下去，重復以上過程，直至最終完成排序。
由於在排序過程中總是小數往前放，大數往後放，相當於氣泡往上升，所以稱作冒泡排序。

for(int
j=0;j<=len-i-1;j++),冒泡排序比較相鄰的值，也就是a[j]和a[j+1]相比較
所以這段代碼從a[0]開始與後面的a[1]比較，如果a[1]小於
a[0]就換。不小於j++，a[1]和[a2]比較，以此類推，直到比到a[len-i-1]時，也就比到了最後一個數組了。上層循環就是控制數組比較的長度。

❷ Java幾種簡單的排序源代碼

給你介紹4種排序方法及源碼，供參考

1.冒泡排序

主要思路： 從前往後依次交換兩個相鄰的元素，大的交換到後面，這樣每次大的數據就到後面，每一次遍歷，最大的數據到達最後面，時間復雜度是O(n^2)。

• publicstaticvoidbubbleSort(int[]arr){

• for(inti=0;i<arr.length-1;i++){

• for(intj=0;j<arr.length-1;j++){

• if(arr[j]>arr[j+1]){

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

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

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

• }

• }

• }

• }

2.選擇排序

主要思路：每次遍歷序列，從中選取最小的元素放到最前面，n次選擇後，前面就都是最小元素的排列了，時間復雜度是O(n^2）。

• publicstaticvoidselectSort(int[]arr){

• for(inti=0;i<arr.length-1;i++){

• for(intj=i+1;j<arr.length;j++){

• if(arr[j]<arr[i]){

• arr[j]=arr[j]^arr[i];

• arr[i]=arr[j]^arr[i];

• arr[j]=arr[j]^arr[i];

• }

• }

• }

• }

3.插入排序

主要思路：使用了兩層嵌套循環，逐個處理待排序的記錄。每個記錄與前面已經排好序的記錄序列進行比較，並將其插入到合適的位置，時間復雜度是O(n^2）。

• publicstaticvoidinsertionSort(int[]arr){

• intj;

• for(intp=1;p<arr.length;p++){

• inttemp=arr[p];//保存要插入的數據

• //將無序中的數和前面有序的數據相比，將比它大的數，向後移動

• for(j=p;j>0&&temp<arr[j-1];j--){

• arr[j]=arr[j-1];

• }

• //正確的位置設置成保存的數據

• arr[j]=temp;

• }

• }

4.希爾排序

主要思路：用步長分組，每個分組進行插入排序，再慢慢減小步長，當步長為1的時候完成一次插入排序， 希爾排序的時間復雜度是：O（nlogn）～O（n2），平均時間復雜度大致是O(n^1.5)

• publicstaticvoidshellSort(int[]arr){

• intj;

• for(intgap=arr.length/2;gap>0;gap/=2){

• for(inti=gap;i<arr.length;i++){

• inttemp=arr[i];

• for(j=i;j>=gap&&temp<arr[j-gap];j-=gap){

• arr[j]=arr[j-gap];

• }

• arr[j]=temp;

• }

• }

• }

❸ java中排序演算法代碼

package temp;
import sun.misc.Sort;
/**
* @author zengjl
* @version 1.0
* @since 2007-08-22
* @Des java幾種基本排序方法
*/
/**
* SortUtil:排序方法
* 關於對排序方法的選擇：這告訴我們，什麼時候用什麼排序最好。當人們渴望先知道排在前面的是誰時，
* 我們用選擇排序；當我們不斷拿到新的數並想保持已有的數始終有序時，我們用插入排序；當給出的數
* 列已經比較有序，只需要小幅度的調整一下時，我們用冒泡排序。
*/
public class SortUtil extends Sort {
/**
* 插入排序法
* @param data
* @Des 插入排序(Insertion Sort)是，每次從數列中取一個還沒有取出過的數，並按照大小關系插入到已經取出的數中使得已經取出的數仍然有序。
*/
public int[] insertSort(int[] data) {
1/11頁
int temp;
for (int i = 1; i < data.length; i++) {
for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {
swap(data, j, j - 1);
}
}
return data;
}
/**
* 冒泡排序法
* @param data
* @return
* @Des 冒泡排序(Bubble Sort)分為若干趟進行，每一趟排序從前往後比較每兩個相鄰的元素的大小（因此一趟排序要比較n-1對位置相鄰的數）並在
* 每次發現前面的那個數比緊接它後的數大時交換位置；進行足夠多趟直到某一趟跑完後發現這一趟沒有進行任何交換操作（最壞情況下要跑n-1趟，
* 這種情況在最小的數位於給定數列的最後面時發生）。事實上，在第一趟冒泡結束後，最後面那個數肯定是最大的了，於是第二次只需要對前面n-1
* 個數排序，這又將把這n-1個數中最小的數放到整個數列的倒數第二個位置。這樣下去，冒泡排序第i趟結束後後面i個數都已經到位了，第i+1趟實
* 際上只考慮前n-i個數（需要的比較次數比前面所說的n-1要小）。這相當於用數學歸納法證明了冒泡排序的正確性

❹ 求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語言完成

冒泡排序的原理：

從第一個元素開始，將相鄰的兩個元素依次進行比較，直到最後兩個元素完成比較。如果前一個元素比後一個元素大，則交換它們的位置。整個過程完成後最後一個元素就是最大值，完成第一輪比較，後邊通過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]+" ");

}

}

}

運行結果截圖：

(5)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冒泡排序代碼

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

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

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

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

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

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

publicclassBubbleSort{
publicstaticvoidmain(String[]args){
intscore[]={67,69,75,87,89,90,99,100};
for(inti=0;i<score.length-1;i++){//最多做n-1趟排序
for(intj=0;j<score.length-i-1;j++){//對當前無序區間score[0......length-i-1]進行排序(j的范圍很關鍵，這個范圍是在逐步縮小的)
if(score[j]<score[j+1]){//把小的值交換到後面
inttemp=score[j];
score[j]=score[j+1];
score[j+1]=temp;
}
}
System.out.print("第"+(i+1)+"次排序結果：");
for(inta=0;a<score.length;a++){
System.out.print(score[a]+"	");
}
System.out.println("");
}
System.out.print("最終排序結果：");
for(inta=0;a<score.length;a++){
System.out.print(score[a]+"	");
}
}
}

❼ java這個冒泡排序是怎麼回事

首先可以肯定的是你這個代碼肯定是完全沒問題的，這就是冒泡排序的寫法：

至於這個問題，我認為最好的解決方法就是重新創一個類，然後把代碼復制過去試試。

❽ 用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代碼

方法一:
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;i<len;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;i<len;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;i<leng;i++)
{
System.out.print(numb[i]+"\t");
}
System.out.println("\n");
swap(numb);
System.out.println("數組排序後:");
for(int
i=0;i<leng;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;i<leng;i++)
{
System.out.print(numb[i]+"\t");
}
System.out.println("\n");
swap(numb);
System.out.println("數組排序後:");
for(int
i=0;i<leng;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冒泡排序

packageTest;

importjava.util.Arrays;

publicclassDemo1{
	publicstaticvoidmain(String[]args){
		int[]a={2,1,3,9,7,10,8,11,17,6};
		//System.out.println(Arrays.toString(a));
		sortArr(a,a.length-1,0);
		System.out.println(Arrays.toString(a));
		sort(a);
		System.out.println(Arrays.toString(a));
	}
	
	publicstaticvoidsortArr(int[]a,inti,intj){	
		if(j<i){
			sortOne(a,i,j);
		}else{			
			sortOne(a,--i,0);			
		}		
	}
	
	publicstaticvoidsortOne(int[]a,inti,intj){
		if(i==0)return;
		if(a[j+1]<a[j]){
			inttemp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
		}	
		sortArr(a,i,++j);
	}
	
	publicstaticvoidsort(int[]a)
	{
	inttemp=0;
	for(inti=a.length-1;i>0;--i)
	{
	for(intj=0;j<i;++j)
	{
	if(a[j+1]<a[j])
	{
	temp=a[j];
	a[j]=a[j+1];
	a[j+1]=temp;
	}
	}
	}
	}
}

上面代碼是從小到大排列

packageTest;

importjava.util.Arrays;

publicclassDemo1{
	publicstaticvoidmain(String[]args){
		Object[]a={2,1,3,9,7,10,8,11,17,6};	
		sortArr(a,a.length-1,0);
		System.out.println(Arrays.toString(a));
		Object[]b={'a','m','s','b','h','e'};
		sortArr(b,b.length-1,0);
		System.out.println(Arrays.toString(b));

	}
	
	publicstaticvoidsortArr(Object[]a,inti,intj){	
		if(j<i){
			sortOne(a,i,j);
		}else{			
			sortOne(a,--i,0);			
		}		
	}
	
	publicstaticvoidsortOne(Object[]a,inti,intj){
		if(i==0)return;
		if(a[j+1]instanceofInteger){
			if(Integer.valueOf(""+a[j+1])<Integer.valueOf(""+a[j])){
				Objecttemp=a[j];
	a[j]=a[j+1];
	a[j+1]=temp;
			}	
		}elseif(a[j+1]instanceofCharacter){
			if(a[j+1].toString().charAt(0)<a[j].toString().charAt(0)){
				Objecttemp=a[j];
	a[j]=a[j+1];
	a[j+1]=temp;
			}	
		}
		sortArr(a,i,++j);
	}
	
//	publicstaticvoidsort(int[]a)
//	{
//	inttemp=0;
//	for(inti=a.length-1;i>0;--i)
//	{
//	for(intj=0;j<i;++j)
//	{
//	if(a[j+1]<a[j])
//	{
//	temp=a[j];
//	a[j]=a[j+1];
//	a[j+1]=temp;
//	}
//	}
//	}
//	}
}