冒泡java

『壹』 冒泡社區java與真正的java有什麼區別

冒泡不可能支持JAVA,純粹唬人,因為虛擬內存嚴重不足,國產或山寨都是五六百KB左右,沒個十來兆是不夠的,建議樓主別買這些,現在諾基亞五六百S40系統的還是很不錯的,比國廠好太多了.手機黨,純手打,望納！

『貳』 怎麼用JAVA實現冒泡排序

static void BubbleSort(int a []){
int temp=0;
for (int i = 0; i < a.length ; i++) {
for (int j = 0; j < a.length - i - 1; j++){
if (a[j]>a[j + 1]){ //把這里改成大於，就是升序了
temp=a[j];
a[j]=a[j + 1];
a[j + 1]=temp;
}
}
}
}

『叄』 java冒泡排序

public class sort{
/** * 數組排序 */
public static void main(String[] args){
int a;
int shuzu[]={19,26,95,34,75,62,18,96,35,75,25};
for(int x=0;x<shuzu.length-1;x++){
for(int y=0;y<(shuzu.length-1);y++){
if(shuzu[x]<shuzu[y]){ //你都用了X循環，變數里卻不用，浪費資源，改代碼就沒問題了
a=shuzu[x];
shuzu[x]=shuzu[y];
shuzu[y]=a;
}
}
}
for(int j=0;j<shuzu.length-1;j++){
System.out.print(shuzu[j]+" ");
}
}
}

『肆』 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冒泡排序

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

『陸』 java實現冒泡排序

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

『柒』 java中的冒泡排序

for(int j=0;i<monkeys.length-1-i;j++)
{
if(monkeys[j].height>monkeys[j+1].height) //該行會報數組越界錯誤

第一行。。for(int j=0;i<monkeys.length-1-i;j++)中的i<monkeys.length-1-i明顯邏輯不對。。該是j<monkeys.length-1-i吧

『捌』 冒泡排序java是

冒泡排序演算法：

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

演算法：取出最大的放在最後，下次就不用比較最後一個了。*/

public class BubbleSort{

public static void main(String[] args){

int[] a = {3,1,6,2,5};

//開始排序

for(int i=a.length-1;i>0;i--){

for(int j=0;j<i;j++){

if(a[j]>a[j+1]){

//交換位置

int temp;

temp = a[j];

a[j] = a[j+1];

a[j+1] = temp;

//遍歷

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

System.out.println(a[i]);

}

演算法原理

冒泡排序演算法的運作如下：（從後往前）

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

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

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

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

『玖』 JAVA冒泡

冒泡就是兩兩交換。。
每循環一次就排好一個數。

10 8 18 7 4
冒泡排序就是內循環
首先用10跟8去比較，10大於8，就進行交換
8 10 18 7 4
然後用10跟18比，不用交換
再用18跟7比，交換，最後跟4比，交換。
第一次外循環結束。
8 10 7 4 18
然後再用8去跟後面的比。。
而18已經排好了，所以就不需要再比較了。。

『拾』 java中的冒泡排序法

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