冒泡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，即去掉数组中最后一个数（也就是最大的一个）。
外层循环控制内层循环执行几次。