Ⅰ 關於冒泡排序法(java)
呵呵，冒泡排序的話，已經排好的元素不再參與比較，所以改成上面那位同學說的或者如果你想保持你的這種比較順序的話，
for(int i=a.length-1; i>=0; i--){
for(int j=0; j<a.length; j++){
應該改成
for(int i=a.length-1; i>=0; i--){
for(int j=0; j<i; j++){
Ⅱ java 用冒泡排序法排序字元串數組
@org.junit.Test
publicvoidb(){
String[]strs={"avcd","bdce","avcdf","cced","bdce"};
for(inti=0;i<strs.length;i++){
//第一個字元的ascii碼大，放前面
for(intj=i+1;j<strs.length;j++){
intnum=0;
compare(strs,i,j,num);
}
}
for(Stringstring:strs){
System.err.println(string);
}
}
/**
*@paramstrs
*@parami
*@paramnum
*/
privatevoidcompare(String[]strs,inti,intj,intnum){
//判斷2個字元串誰的長度最小，則以當前長度作為num+1的最大標准
if(strs[i].length()>=strs[j].length()){
if(num+1<=strs[j].length()){
if(strs[j].charAt(num)>strs[i].charAt(num)){
Stringtemp=strs[i];
strs[i]=strs[j];
strs[j]=temp;
//若相等，則判斷第二個
}elseif(strs[j].charAt(num)==strs[i].charAt(num)){
num++;
compare(strs,i,j,num);
}
}
}else{
if(num+1<=strs[i].length()){
if(strs[j].charAt(num)>strs[i].charAt(num)){
Stringtemp=strs[i];
strs[i]=strs[j];
strs[j]=temp;
//若相等，則判斷第二個
}elseif(strs[j].charAt(num)==strs[i].charAt(num)){
num++;
compare(strs,i,j,num);
}
}else{
//表示當前字元串內容都一致，strs[j]的長度大。則放前面。
Stringtemp=strs[i];
strs[i]=strs[j];
strs[j]=temp;
}
}
}
Ⅲ 用JAVA語言編寫一個冒泡排序法，要詳細的
我n年前上學用的，你看看把，呵呵。希望對你有幫助
public class Test
{
public void Sx(int[] t)
{
for(int i = 0;i < t.length;i++)
{
if(t[i] < 10)
{
System.out.print("0"+t[i]+" ");
}
else
{
System.out.print(t[i]+" ");
}
if((i+1) % 6 == 0)
{
System.out.println();
}
}
}
public static void main(String[] args)
{
Test m = new Test();
int a[] = new int[36];
out1: for(int i = 0;i < 36;i++)
{
a[i] = (int)(Math.random() * 36 + 1);
for(int j = 0; j < 36 && j != i;j++)
{
if(a[j] == a[i])
{
i--;
continue out1;
}
}
}
m.Sx(a);
System.out.println();
//Arrays.sort(a);
//冒泡法
int temp;
for(int i=0;i<a.length;i++){
for(int j=0;j+1<a.length-i;j++){
if(a[j]>a[j+1]){
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
m.Sx(a);
}
}
Ⅳ 求JAVA冒泡排序法的代碼
你好！很高興能幫到你。
由於你剛學Java，所以一些編程規范是需要注意的，而我提供給你的答案看起來雖然有點復雜，不過採用了面向對象的編程思想，盡量做到低耦合高內聚，同時冒泡演算法也做了升級，為冒泡的高級快速排序演算法，不過為了對比，也保存了傳統的冒泡演算法。
需要講解一下，演算法本身不難，難在如何做到編程規范、以及方便修改、易於修改、使得程序靈活、低耦合高內聚。
演算法部分請看Bubble類，裡面有兩種演算法，有注釋。
主類為TestBubble，主要用於調用Bubble對象運行演算法、StuInfo對象提供學生作者信息、Info對象提供運行過程中提示信息。
運行結果如下（Bubble類為核心演算法類）：
************************************
run：
請輸入您將要輸入整數的個數：
10
請輸入一串數字進行冒泡排序，注意：每次只輸入一個，輸完則回車
1:10
2:23
3:11
4:56
5:45
6:26
7:59
8:28
9:84
10:79
初始序列的數組為：
10 23 11 56 45 26 59 28 84 79
學號：200815009* 班級:08軟體3班 姓名：葉科良
排序好的數組為：
10 11 23 26 28 45 56 59 79 84
源代碼如下：
***************************************************
package testBubble;
import java.io.Reader;
import java.util.Scanner;
/**
*
* @author yekeliang
*/
public class TestBubble {
private CommandLineBubbleRunner commandLineBubbleRunner;
private int arraySize;
private int[] intArray;
private StuInfo stuInfo;
private Info info;
/**
* 測試方法
* @param args
*/
public static void main(String[] args) {
TestBubble test = new TestBubble();
}
/**
* 構造方法
* 調用初始化學生數據、接收命令行整數、展示結果3個成員方法
*/
public TestBubble() {
initMemb();
initData();
runBubble();
showResult(this.getIntArray());
}
/**
* 初始化學生數據
*/
private void initData() {
stuInfo.setStuNum("200815009*");
stuInfo.setStuClass("08軟體3班");
stuInfo.setStuName("葉科良");
info.setInputIntNumInfo("請輸入您將要輸入整數的個數：");
info.setInputIntInfo("請輸入一串數字進行冒泡排序，注意：每次只輸入一個，輸完則回車");
info.setShowInputInfo("初始序列的數組為：");
info.setShowResultInfo("排序好的數組為：");
info.setInputErrorInfo("對不起，輸入有誤！請輸入整數.");
}
/**
* 接收命令行整數，使用冒泡演算法
*/
private void runBubble() {
try{
System.out.println(info.getInputIntNumInfo());
setArraySize(getCommandLineBubbleRunner().getArraySize());
System.out.println(info.getInputIntInfo());
setIntArray(getCommandLineBubbleRunner().getAcceptAsIntArray(getArraySize()));
System.out.println(info.getShowInputInfo());
getCommandLineBubbleRunner().showAcceptAsIntArray(getIntArray());
Bubble.quick(getIntArray());
} catch(java.util.InputMismatchException e) {
System.out.println(info.getInputErrorInfo());
}
}
/**
* 展示結果
*/
private void showResult(int intArray[]) {
System.out.println("\n" + stuInfo.toString());
System.out.println(info.getShowResultInfo());
for (int i = 0; i < intArray.length; i++) {
System.out.print(intArray[i] + " ");
}
}
private void initMemb() {
stuInfo = new StuInfo();
info = new Info();
commandLineBubbleRunner = new CommandLineBubbleRunner();
}
public CommandLineBubbleRunner getCommandLineBubbleRunner() {
return commandLineBubbleRunner;
}
public void setCommandLineBubbleRunner(CommandLineBubbleRunner commandLineBubbleRunner) {
this.commandLineBubbleRunner = commandLineBubbleRunner;
}
public int getArraySize() {
return arraySize;
}
public void setArraySize(int arraySize) {
this.arraySize = arraySize;
}
public int[] getIntArray() {
return intArray;
}
public void setIntArray(int[] intArray) {
this.intArray = intArray;
}
private void getStuInfo() {}
}
/**
*
* @author 葉科良
*/
class CommandLineBubbleRunner {
public int num;//輸入整數個數
/**
* 從命令行中讀取需要輸入的整數個數
* @return 需要輸入的整數個數
*/
public int getArraySize() {
Scanner reader1 = new Scanner(System.in);
num = reader1.nextInt();
return num;
}
/**
* 指定數組大小，從命令行接收整數
* @param arraySize 數組大小
* @return 原始整數數組
*/
public int[] getAcceptAsIntArray(int arraySize) {
int[] acceptArray = new int[arraySize];
Scanner reader = new Scanner(System.in);
for (int i = 0; i < getNum(); i++) {
System.out.print((i + 1) + ":");
acceptArray[i] = reader.nextInt();
}
return acceptArray;
}
/**
* 列印原始輸入數據
* @param intArray
*/
public void showAcceptAsIntArray(int[] intArray){
for (int i = 0; i < getNum(); i++) {
System.out.print(intArray[i] + " ");
}
}
/**
* 取得數組大小
* @return
*/
public int getNum() {
return num;
}
}
class Bubble {
/**
* 給定一個數組，使用冒泡演算法進行排序
* @param acceptArray 給定的一個數組
* @return 排序好的數組
*/
public static int[] getResultAsIntArray(int[] acceptArray) {
int i, temp;
for (i = 0; i < (acceptArray.length - 1); i++) {//兩兩進行比較，符合條件的進行交換
if (acceptArray[i] > acceptArray[i + 1]) {
temp = acceptArray[i];
acceptArray[i] = acceptArray[i + 1];
acceptArray[i + 1] = temp;
}
}
return acceptArray;
}
/**
* 快速冒泡排序演算法
* @param r 輸入的整數數組
* @param first 數組第一個下標
* @param end 數組最後一個下標
* @return 排好序的整數數組
*/
public static int partition(int[] r, int first, int end) {
int i, j;
i = first;
j = end;
while (i < j) {
while (i < j && r[i] <= r[j]) {
j--;
}
if (i < j) {
int temp;
temp = r[i];
r[i] = r[j];
r[j] = temp;
}
}
return i;
}
public static void quick(int[] r, int first, int end) { //利用遞歸反復劃分
if (first < end) {
int pivot = partition(r, first, end); //調用劃分函數
quick(r, first, pivot - 1);
quick(r, pivot + 1, end);
}
}
public static int[] quick(int[] r){
quick(r,0,r.length-1);
return r;
}
}
class Info {
private String inputIntNumInfo;//提示用戶輸入整數個數的消息語句
private String inputIntInfo;//提示用戶輸入整數的消息語句
private String showInputInfo;//提示顯示用戶輸入整數的消息語句
private String inputErrorInfo;//提示用戶輸入有誤消息語句
private String showResultInfo;//提示顯示排序結果
public String getInputIntNumInfo() {
return inputIntNumInfo;
}
public void setInputIntNumInfo(String inputIntNumInfo) {
this.inputIntNumInfo = inputIntNumInfo;
}
public String getInputIntInfo() {
return inputIntInfo;
}
public void setInputIntInfo(String inputIntInfo) {
this.inputIntInfo = inputIntInfo;
}
public String getShowInputInfo() {
return showInputInfo;
}
public void setShowInputInfo(String showInputInfo) {
this.showInputInfo = showInputInfo;
}
public String getInputErrorInfo() {
return inputErrorInfo;
}
public void setInputErrorInfo(String inputErrorInfo) {
this.inputErrorInfo = inputErrorInfo;
}
public String getShowResultInfo() {
return showResultInfo;
}
public void setShowResultInfo(String showResultInfo) {
this.showResultInfo = showResultInfo;
}
}
class StuInfo {
private String stuNum;//學生學號
private String stuName;//學生姓名
private String stuClass;//學生班級
@Override
public String toString() {
return "學號：" + getStuNum() + " 班級:" + getStuClass() + " 姓名：" + getStuName();
}
public String getStuNum() {
return stuNum;
}
public void setStuNum(String stuNum) {
this.stuNum = stuNum;
}
public String getStuName() {
return stuName;
}
public void setStuName(String stuName) {
this.stuName = stuName;
}
public String getStuClass() {
return stuClass;
}
public void setStuClass(String stuClass) {
this.stuClass = stuClass;
}
}
Ⅳ 關於JAVA中的冒泡排序法
package pck;//打開pck數據包
public class Bubble {//建立一個名為Bubble的類
public static void main(String args[]){//建立main函數
int nums[]={99,-10,100123,18,-978,5623,463,-9,287,49};//建立名為nums的數組，包含10個數，並為這10個數初始化值
int a,b,t;建立3個整型變數
System.out.print("Original array is:");//屏幕輸出Original array is:這段字元
for(int i=0;i<10;i++)//循環
System.out.print(" "+nums[i]);//屏幕上依次顯示空格+nums[0]的數值空格+nums[1]……+nums[9]
System.out.println();
for(a=1;a<10;a++)
for(b=10-1;b>=a;b--){
if(nums[b-1]>nums[b]){//當後面的數大於前面的數是執行調換
t=nums[b-1];
nums[b-1]=nums[b];
nums[b]=t;
}
}//一段for語句循環，意思是把數組里大的數吊到前面，小的放到後面
System.out.print("Sroted array is:");屏幕上輸出Sroted array is:這段字元
for(int i=0;i<10;i++)//循環語句為後面輸出nums里的數作準備
System.out.print(" "+nums[i]);//在屏幕上輸出空格+nums[0]空格+nums[1]……nums[9]
System.out.println();//這句不太清楚，可能是輸出空白行
}
}
Ⅵ 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++){
//交換位置
}
Ⅶ java中的冒泡排序法
內層循環一次得到這個數組中最大的數並把它放在數組最後一個，同時把內層需要再循環的數組長度減1，即去掉數組中最後一個數（也就是最大的一個）。
外層循環控制內層循環執行幾次。
Ⅷ 新手提問：java冒泡排序法
你這個冒泡排序有點錯誤
代碼應如下
11. for (int i=0;i<num.length;i++) { // 執行冒泡排序法
12. for (int j=num.length-1;j>i;j--) {
// 兩個相鄰的數比較，若前一個數比後面的數大，則交換位置
13 if (array[j]<array[j-1]){
14 mid = array[j-1];
15 array[j-1] = array[j];
16 array[j] = array[j-1];
17 }
11，12行是確定你的排列順序是沉（從array[0]開始比較）還是浮（從數組尾開始比較）
以上代碼順序是浮，從array[]末開始，比較相鄰的兩個元素，按照一定的順序，這里是把比較小的數冒上來。每一次內循環都會有一個最小值冒出來，第一次是全數組中冒出一個最小的確定在array[0]位置中，然後第二次也是從末端開始比較，最後確定一個最值在array[1]中，以此類推。
冒泡排序是每次比較兩個數據，按照大小順序交換位置，每一次循環都把一個最值確定，下一次就可以少比較一個數，直到整個數組位置都確定。
Ⅸ java中最簡單的方法冒泡排序
public void bubbleSort(int[] data, String sortType) {
if (sortType.equals("asc")) { //正排序，從小排到大
//比較的輪數
for (int i = 1; i < data.length; i++) {
//將相鄰兩個數進行比較，較大的數往後冒泡
for (int j = 0; j < data.length - i; j++) {
if (data[j] > data[j + 1]) {
//交換相鄰兩個數
swap(data, j, j + 1);
}
}
}
} else if (sortType.equals("desc")) { //倒排序，從大排到小
//比較的輪數
for (int i = 1; i < data.length; i++) {
//將相鄰兩個數進行比較，較大的數往後冒泡
for (int j = 0; j < data.length - i; j++) {
if (data[j] < data[j + 1]) {
//交換相鄰兩個數
swap(data, j, j + 1);
}
}
}
} else {
System.out.println("您輸入的排序類型錯誤！");
}
printArray(data);//輸出冒泡排序後的數組值
}
Ⅹ 關於冒泡排序的JAVA程序
冒泡演算法，沒冒一次泡，會將所有的數據比較一遍，同時將當前最大的數冒上去。
如果isSort 等於false ，表示所有比較中都沒有發生需要交換的行為，那麼數據已經按要求排序了。不必進行下一次冒泡。
這樣可以減少重復計算量。