java數組的冒泡排序

1. 誰能詳細的解釋下java中的冒泡排序 謝謝- .-

int
array[]=new
int[]{9,2,3,1,0,5,8,4,7,6};//初始化一個數組，長度為10
int
temp;//定義一個臨時變數，
System.out.println("原有數組內容：");//輸出這幾個漢字
printArray(array);//調用printArray方法，並將前面初始化的數組作為參數傳遞給該方法
for(int
i
=1;i<array.length;i++){//這里應該是演算法的核心了，但是如果想理解，還是先看看內層的循環，
for(int
j
=0;j<array.length-i;j++){//循環了0到數組長度10-1
一共10次
if(array[j]>array[j+1]){//數組的第一個元素a[0]與第二個元素a[1]做比較，如果大於，第2個元素
temp=array[j];//那麼將大的那個值a[0]的值賦值給臨時變數
array[j]=array[j+1];//再將a[1]的值賦值給a[0]
array[j+1]=temp;//最後把臨時變數中的值復制給a[1]
//看懂這里了嗎？如果前面的數，或者形象點a[0]
,a[1],..依次往上排，那麼就是如果排在下面的數組元素的值大於上面的數組元素的值那麼就將這兩個元素的位置換一下，大的放上面，也就是排在數組的後面，像不像冒泡，水中的氣泡，越到上面越大；如果小的話當然就沒關系了，還是小的在下面
}
//這一次內層循環做完之後，保證了最下面的氣泡（數組元素的位置），它跟後面所有的元素都做了一次比較，如果它最大就能排到最上面
}
//最外層的循環保證了，從頭到尾將所有的數組元素按照從前到後，或者從下到上的順序都與後面的元素比較了一次，這就完成了所有元素的排序
}
System.out.println("從小到大排序後的結果：");
printArray(array);
}
private
static
void
printArray(int[]
array)
{//來看看，這個方法做了什麼，在上面調用這個方法的時候已經將你初始化的那個長度為10的數組做為參數傳遞了進來
//
TODO
Auto-generated
method
stub
for(int
i
:
array){//用增強for循環，遍歷這個數組
System.out.print(i+"
");//一次列印i的值和空格
}
System.out.println("\n");//都遍歷結束後，換行
}
輸入內容已經達到長度限制
還能輸入
9999
字
希望你滿意，遇到問題多多分析！

2. 用java對象數組怎樣進行冒泡排序

/**
* 冒泡排序
*/
public class Example6_6{
public static void main(String[] agrs){
int[] intArray=new int[]{3,0,1,18,5,0,-5,-6,3}; //定義序列
int tempLength=intArray.length;
for(;--tempLength>0;){
for(int index=0;index<tempLength;++index){
//如果相鄰的左邊元素小於右邊的元素，則互換
if(intArray[index]<intArray[index+1]){
int temp=intArray[index];
intArray[index]=intArray[index+1];
intArray[index+1]=temp;
}
}
}
//輸入已經排好序的數組
for(int index=0;index<intArray.length;++index){
System.out.print(intArray[index]+"\t");
}
}
}

3. java冒泡排序法代碼

冒泡排序是比較經典的排序演算法。代碼如下：

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

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

//交換位置

}

拓展資料：

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

思路：依次比較相鄰的兩個數，將小數放在前面，大數放在後面。即在第一趟：首先比較第1個和第2個數，將小數放前，大數放後。然後比較第2個數和第3個數，將小數放前，大數放後，如此繼續，直至比較最後兩個數，將小數放前，大數放後。重復第一趟步驟，直至全部排序完成。

第一趟比較完成後，最後一個數一定是數組中最大的一個數，所以第二趟比較的時候最後一個數不參與比較；

第二趟比較完成後，倒數第二個數也一定是數組中第二大的數，所以第三趟比較的時候最後兩個數不參與比較；

依次類推，每一趟比較次數-1；

……

舉例說明：要排序數組：int[]arr={6,3,8,2,9,1};

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

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

//交換位置

}

4. 用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]);
}
}
}

5. java中的冒泡排序法

內層循環一次得到這個數組中最大的數並把它放在數組最後一個，同時把內層需要再循環的數組長度減1，即去掉數組中最後一個數（也就是最大的一個）。
外層循環控制內層循環執行幾次。

6. java怎麼讓數組的數字從大到小排序

將數字從大到小排序的方法：

例如簡一點的冒泡排序，將第一個數字和後面的數字逐個比較大小，如果小於，則互換位置，大於則不動。此時，第一個數為數組中的最大數。然後再將第二個數與後面的數逐個比較，以次類推。

示例代碼如下：
publicclassTest{

publicstaticvoidmain(String[]args){
int[]array={12,3,1254,235,435,236,25,34,23};
inttemp;
for(inti=0;i<array.length;i++){
for(intj=i+1;j<array.length;j++){
if(array[i]<array[j]){
temp=array[i];
array[i]=array[j];
array[j]=temp; //兩個數交換位置
}
}
}
for(inti=0;i<array.length;i++){
System.out.print(array[i]+"");
}
}
}

數組對於每一門編程語言來說都是重要的數據結構之一，當然不同語言對數組的實現及處理也不盡相同。

Java 語言中提供的數組是用來存儲固定大小的同類型元素。

你可以聲明一個數組變數，如 numbers[100] 來代替直接聲明 100 個獨立變數 number0，number1，....，number99

(6)java數組的冒泡排序擴展閱讀

Java中利用數組進行數字排序一般有4種方法：

1、選擇排序是先將數組中的第一個數作為最大或最小數，然後通過循環比較交換最大數或最小數與一輪比較中第一個數位置進行排序。

2、冒泡排序也是先將數組中的第一個數作為最大或最小數，循環比較相鄰兩個數的大小，滿足條件就互換位置，將最大數或最小數沉底。

3、快速排序法主要是運用Arrays類中的Arrays.sort方法（）實現。

4、插入排序是選擇一個數組中的數據，通過不斷的插入比較最後進行排序。

7. java定義一個整型數組將數組中的元素用冒泡排序法升序排序

請看：

/*
*冒泡排序
*/
publicclassBubbleSort{
publicstaticvoidmain(String[]args){
int[]arr={6,3,8,2,9,1};
System.out.println("排序前數組為：");
for(intnum:arr){
System.out.print(num+"");
}
for(inti=0;i<arr.length-1;i++){//外層循環控制排序趟數
for(intj=0;j<arr.length-1-i;j++){//內層循環控制每一趟排序多少次
if(arr[j]>arr[j+1]){
inttemp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
System.out.println();
System.out.println("排序後的數組為：");
for(intnum:arr){
System.out.print(num+"");
}
}
}

8. 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;
//	}
//	}
//	}
//	}
}

9. 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;
}
}
} } }

10. 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]+"	");
}
}
}