java编写冒泡算法_用java写个冒泡排序

Ⅰ 关于java中的冒泡算法

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Sort {
public static void main(String[] args) {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
while (true) {
System.out.println("请输入数字，以空格分隔:");
try {
String input = br.readLine();
String[] vector = input.split(" ");
int[] num = new int[vector.length];
for (int i = 0; i < vector.length; i++) {
num[i] = Integer.parseInt(vector[i]);
}
for (int j = 0; j < vector.length; j++) {
for (int k = 1; k < vector.length - 1; k++) {
if (num[k] > num[k + 1]) {
int temp = num[k + 1];
num[k + 1] = num[k];
num[k] = temp;
}
}
System.out.print(num[j] + " ");

}
System.out.println();
} catch (NumberFormatException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
程序没问题,注意只能输入整数,而且要用一个空格隔开,多个空格或者其他符号隔开就出问题~

Ⅱ “JAVA写冒泡排序”是什么意思

冒泡排序的英文Bubble Sort，是一种最基础的交换排序。

大家一定都喝过汽水，汽水中常常有许多小小的气泡，哗啦哗啦飘到上面来。这是因为组成小气泡的二氧化碳比水要轻，所以小气泡可以一点一点向上浮动。而我们的冒泡排序之所以叫做冒泡排序，正是因为这种排序算法的每一个元素都可以像小气泡一样，根据自身大小，一点一点向着数组的一侧移动。

冒泡排序算法的原理如下：

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

具体如何来移动呢？让我们来看一个栗子：

希望对您有所帮助！~

Ⅲ 用java语言实现冒泡法

题主你好，很高兴回答你的问题，我这里有一个写好的，你可以参考下，希望能帮到你，望采纳。

publicclassBubbleSort{
	publicstaticvoidmain(String[]args){
		int[]number={95,45,15,78,84,51,24,12};
		inttemp=0;
		for(inti=0;i<number.length-1;i++)
			for(intj=0;j<number.length-1-i;j++)
				if(number[j]>number[j+1]){
					temp=number[j];
					number[j]=number[j+1];
					number[j+1]=temp;
				}//ifend
		System.out.println(System.currentTimeMillis()+"");
		for(inti=0;i<number.length;i++)System.out.print(number[i]+"");
		System.out.println();
	}//mainend
}

Ⅳ 如何Java编写冒泡程序，要求是从键盘输入一个正整数n表示个数，然后输

importjava.io.BufferedReader;
importjava.io.InputStreamReader;

publicclassMaoPaoPaiXu{
	publicstaticvoidmain(String[]args)throwsException{
		System.out.println("请输入要输入的正整数个数：");
		BufferedReaderbr=newBufferedReader(newInputStreamReader(System.in));
		Stringnum=br.readLine();
		
		intlen=Integer.parseInt(num);
		int[]source=newint[len];
		System.out.println("请输入正整数，每个正整数之间用","分割：");
		
		StringsourceString=br.readLine();
		br.close();
		String[]sourceStrs=sourceString.split(",");
		if(sourceStrs.length!=len){
			System.out.println("输入的正整数个数和输入的正整数数量不匹配。");
			return;
		}
		for(inti=0;i<sourceStrs.length;i++){
			source[i]=Integer.parseInt(sourceStrs[i]);
		}
		//冒泡排序
		inttemp=0;
		for(inti=source.length-1;i>0;--i){
			for(intj=0;j<i;++j){
				if(source[j+1]<source[j]){
					temp=source[j];
					source[j]=source[j+1];
					source[j+1]=temp;
				}
			}
		}
		System.out.println("冒泡排序后的数组内容：");
		StringBuffersb=newStringBuffer();
		for(intstring:source){
			sb.append(string+",");
		}
		System.err.println(sb.toString());
	}
}

运行后的内容：

请输入要输入的正整数个数：

请输入正整数，每个正整数之间用","分割：

876,234,123,2,32,12

冒泡排序后的数组内容：

2,12,32,123,234,876,

Ⅳ 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中编写冒泡排序算法 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）基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

（2）用java实现

ublicclassbubbleSort{

publicbubbleSort(){

inta[]={1,54,6,3,78,34,12,45};

inttemp=0;

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

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

if(a[i]>a[j]){

temp=a[i];

a[i]=a[j];

a[j]=temp;

}

}

}

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

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

}

}

递归

递归算法，就是程序的自身调用。表现在一段程序中往往会遇到调用自身的那样一种coding策略，可以利用大道至简的思想，把一个大的复杂的问题层层转换为一个小的和原问题相似的问题来求解的这样一种策略。能看到我们会用很少的语句解决了非常大的问题，所以递归策略的最主要体现就是小的代码量解决了非常复杂的问题。

java代码：

packagecom.cjq.filedown;

publicclassFab{

publicstaticvoidmain(Stringargs[]){
System.out.println(fab(5));
}

privatestaticintfab(intindex){
if(index==1||index==2){
return1;
}else{
returnfab(index-1)+fab(index-2);
}
}
}

Ⅷ 用java写个冒泡排序

冒泡排序算法：

int类型的数组：3 1 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

。。。

算法：取出最大的放在最后，下次就不用比较最后一个了。*/
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编写冒泡算法

java编写冒泡算法

与java编写冒泡算法相关的资料