java冒泡排序代碼（java實現冒泡排序代碼）

本文目錄一覽：

• 1、Java冒泡排序的原理？
• 2、java冒泡排序代碼
• 3、用java寫個冒泡排序？
• 4、下列java 代碼 冒泡排序 求逐句注釋 謝謝
• 5、JAVA冒泡排序

Java冒泡排序的原理？

冒泡排序是所欲排序演算法里最好理解的了。

1、排序演算法：

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

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

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

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

2、給你一個java的實現代碼：

public class BubbleSort{

     public static void main(String[] args){

         int score[] = {67, 69, 75, 87, 89, 90, 99, 100};

         for (int i = 0; i score.length -1; i++){ //最多做n-1趟排序

             for(int j = 0 ;j score.length – i – 1; j++){ //對當前無序區間score[0……length-i-1]進行排序(j的範圍很關鍵，這個範圍是在逐步縮小的)

                 if(score[j] score[j + 1]){ //把小的值交換到後面

                     int temp = score[j];

                     score[j] = score[j + 1];

                     score[j + 1] = temp;

                 }

             }

             System.out.print(“第” + (i + 1) + “次排序結果：”);

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

                 System.out.print(score[a] + “\t”);

             }

             System.out.println(“”);

         }

             System.out.print(“最終排序結果：”);

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

                 System.out.print(score[a] + “\t”);

        }

     }

 }

java冒泡排序代碼

冒泡排序（Bubble Sort）是一種簡單的排序演算法。它重複地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個演算法的名字由來是因為越小的元素會經由交換慢慢「浮」到數列的頂端。

冒泡排序演算法的運作如下:

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

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

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

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

public class BubbleSort{  

      public static void main(String[] args){  

          int score[] = {67, 69, 75, 87, 89, 90, 99, 100};  

          for (int i = 0; i  score.length -1; i++){    //最多做n-1趟排序  

              for(int j = 0 ;j  score.length – i – 1; j++){    //對當前無序區間score[0……length-i-1]進行排序(j的範圍很關鍵，這個範圍是在逐步縮小的)  

                  if(score[j]  score[j + 1]){    //把小的值交換到後面  

                      int temp = score[j];  

                      score[j] = score[j + 1];  

                      score[j + 1] = temp;  

                  }  

              }              

              System.out.print(“第” + (i + 1) + “次排序結果：”);  

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

                  System.out.print(score[a] + “\t”);  

              }  

              System.out.println(“”);  

          }  

              System.out.print(“最終排序結果：”);  

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

                  System.out.print(score[a] + “\t”);  

         }  

      }  

  }

用java寫個冒泡排序？

冒泡排序演算法：

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

第一次循環：

1 3 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 5

第三次循環：

1 2 3

1 2 3

。。。

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

public class BubbleSort{

    public static void main(String[] args){

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

        //開始排序

        for(int i=a.length-1;i0;i–){

            for(int j=0;ji;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;ia.length;i++){

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

        }

    }

}

下列java 代碼 冒泡排序 求逐句注釋 謝謝

很好懂吧？ 從第一個開始 把第二個到最後一個跟他比 如果小就交換。一次循環下來第一個一定是數組中最小的。然後從第二個開始，比較第三個到最後一個。以此類推。

JAVA冒泡排序

package Test;

import java.util.Arrays;

public class Demo1 {

public static void main(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));

}

public static void sortArr(int[] a,int i,int j){

if(ji){

sortOne(a,i,j);

}else{

sortOne(a,–i,0);

}

}

public static void sortOne (int[] a,int i,int j){

if(i==0)return;

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

 int temp = a[j];

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

             a[j + 1] = temp;

}

sortArr(a,i,++j);

}

 public static void sort(int[] a)

    {

        int temp = 0;

        for (int i = a.length – 1; i  0; –i)

        {

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

            {

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

                {

                    temp = a[j];

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

                    a[j + 1] = temp;

                }

            }

        }

    }

}

上面代碼是從小到大排列

package Test;

import java.util.Arrays;

public class Demo1 {

public static void main(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));

}

public static void sortArr(Object[] a,int i,int j){

if(ji){

sortOne(a,i,j);

}else{

sortOne(a,–i,0);

}

}

public static void sortOne (Object[] a,int i,int j){

if(i==0)return;

if(a[j + 1] instanceof Integer){

if(Integer.valueOf(“”+a[j + 1]) Integer.valueOf(“”+ a[j])){

Object temp = a[j];

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

             a[j + 1] = temp;

}

}else if(a[j + 1] instanceof Character){

if(a[j + 1].toString().charAt(0) a[j].toString().charAt(0)){

Object temp = a[j];

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

             a[j + 1] = temp;

}

}

sortArr(a,i,++j);

}

//  public static void sort(int[] a)

//     {

//         int temp = 0;

//         for (int i = a.length – 1; i  0; –i)

//         {

//             for (int j = 0; j  i; ++j)

//             {

//                 if (a[j + 1]  a[j])

//                 {

//                     temp = a[j];

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

//                     a[j + 1] = temp;

//                 }

//             }

//         }

//     }

}