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編寫冒泡演算法相關的資料