選擇排序與冒泡排序在java中的使用

1.     選擇排序:

例若有下列數組 arr {20,25,30,15,10}.

 

第一次排序,讓數組的第一位數與其後面的每一位數進行比較,將所比的最小的數字放到第一位.

(1)20與25相比較,20比25小,因此數組不變.

(2)20與30相比較,20比30小,因此數組不變.

(3)20與15相比較,20比15大,因此20與15位置交換.

(4)15與10相比較,15比10大,因此15與10位置交換.

這一步驟的程序能夠寫爲

int[] arr = {20,25,30,15,10};

min = arr[0];

for(int i = 1;i<arr.lenght;i++){

        iIf(min >arr){

               inttemp = min;

               min =arr;

               arr= temp;

}

}

arr[0] = min;

      

通過第一個步驟的比較後,第一位變爲了數組中最小的數,因此第二步從數組的第二位開始.

(1)25與30相比較,20比25小,因此數組不變.

(2)25與20相比較,25比20大,因此25與20位置交換.

(3)20與15相比較,20比15大,因此20與15位置交換.

這一步驟的程序能夠寫爲

int[] arr = {10,25,30,20,15};

min = arr[1];

for(int i = 2;i<arr.lenght;i++){

        iIf(min >arr){

               inttemp = min;

               min =arr;

               arr= temp;

}

}

arr[1] = min;

通過第二個步驟的比較後,第二位的數變成了數組中第二小的數,第三步從數組的第三位開始.

(1)30與25相比較,30比25大,因此30與25位置交換.

(2)25與20相比較,25比20大,因此25與20位置交換.

這一步驟的程序能夠寫爲

int[] arr = {10,15,30,25,20};

min = arr[2];

for(int i = 3;i<arr.lenght;i++){

        iIf(min >arr){

               inttemp = min;

               min =arr;

               arr= temp;

}

}

arr[2] = min;

接下來是最後一步,把第四位數字和第五位數字比較.

(1)30與25相比較,30比25大,因此30與25位置交換.

int[] arr = {10,15,20,30,25};

min = arr[3];

for(int i = 4;i<arr.lenght;i++){

        iIf(min >arr){

               inttemp = min;

               min =arr;

               arr= temp;

}

}

arr[3] = min;

經過上述步驟,咱們發現這個四個程序惟一在變的是min的初始值,數組和for中i的值.

因此咱們能夠經過在外面加一個for循環來構成一個循環的嵌套來完成程序.

      

int[] arr = {20,25,30,15,10};

for(int i = 0; i < arr.length-1;i++){

int min = arr;

for(int j = i+1;j<arr.length;j++){

               if(min> arr[j]){

                      int temp = min;

                      min = arr[j];

                      arr[j] = temp;

}

}

arr = min;

}

2.     冒泡排序:

數組與選擇排序的數組相同 arr {20,25,30,15,10}.

第一次排序,讓數組的每一位數與其後一位數進行比較,將所比的較小的數字放到前,較大的數字放到後.

(1)20與25相比較,20比25小,因此數組不變.

(2)25與30相比較,25比30小,因此數組不變.

(3)30與15相比較,30比15大,因此30與15位置交換.

(4)30與10相比較,30比10大,因此30與10位置交換.

       for(inti = 0 ; i < 4 ; i++ ){

              if(arr> arr[i+1]){

                     inttemp = arr[i+1];

                     arr[i+1]= arr;

                     arr= temp;

              }

       }

第二次排序,讓數組的前三位數與其後一位數進行比較,將所比的較小的數字放到前,較大的數字放到後.與第一次排序相比只須要進行三次排序.

(1)20與25相比較,20比25小,因此數組不變.

(2)25與15相比較,25比15大,因此25與15位置交換.

(3)25與10相比較,25比10大,因此25與10位置交換.

for(int i = 0 ;i < 3 ; i++ ){

              if(arr> arr[i+1]){

                     inttemp = arr[i+1];

                     arr[i+1]= arr;

                     arr= temp;

              }

       }

第三次排序,讓數組的前兩位數與其後一位數進行比較,將所比的較小的數字放到前,較大的數字放到後.與第一次排序相比只須要進行兩次排序.

(1)20與15相比較,20比15大,因此20與15位置交換.

(2)20與10相比較,20比10大,因此20與10位置交換.

for(int i = 0 ;i < 2 ; i++ ){

              if(arr> arr[i+1]){

                     inttemp = arr[i+1];

                     arr[i+1]= arr;

                     arr= temp;

              }

       }

第四次排序,讓數組的第一位數與其後一位數進行比較,將所比的較小的數字放到前,較大的數字放到後.與第一次排序相比只須要進行一次排序.

(1)20與15相比較,20比15大,因此20與15位置交換.

(2)20與10相比較,20比10大,因此20與10位置交換.

for(int i = 0 ;i < 2 ; i++ ){

              if(arr> arr[i+1]){

                     inttemp = arr[i+1];

                     arr[i+1]= arr;

                     arr= temp;

              }

       }

經過上述步驟,咱們發現這個四個程序惟一在變的是數組和for中i最大值.

因此咱們能夠經過在外面加一個for循環來構成一個循環的嵌套來完成程序.

       int[]arr = {20,25,30,15,10};

       for(intj = arr.length – 1 ; j >= 0 ; j-- ){

              for(inti = 0 ; i < j ; i++){

                     if(arr> arr[i+1]){

                            inttemp = arr[i+1];

                            arr[i+1]= arr;

                            arr= temp;

                     }

              }

       }

 
以上就是數組的選擇排序和冒泡排序.

他們的區別是:

選擇排序是每一排序一輪肯定一個位置的數.

冒泡排序則是每一輪肯定一個數的位置.

冒泡排序對數組排序,其空間上的先後順序並不會由於排序而發生改變,可是因爲其相比較的兩個數不停的變化,會使其複雜程度大大提高.

選擇排序一輪比較只須要變換一個位置的數字,能夠使其排序是的複雜性大大下降,可是如上所述,其破壞了數組中相同數的先後順序.