使用C語言和Java分別實現冒泡排序和選擇排序
阿新 • • 發佈：2017-10-19
都沒有 img 容易 n) 不穩定排序 實現 imp 結果 輸出 
經典排序算法——冒泡和選擇排序法
Java實現冒泡排序
基本思想是，對相鄰的元素進行兩兩比較，順序相反則進行交換，這樣，每一趟會將最小或最大的元素放到頂端，最終達到完全有序，首先看個動圖：
我們要清楚一點，冒泡排序是相鄰元素的兩兩比較，再看下圖是否會清晰些：
輸入的數據為：10 30 40 33 5 78 11 100 23 66
第一次排序，從第一個數10依次比較，若10比後者小，則進行交換，當比較到5時，10比5大，所以10就停在第四個位置，再用5去比較，後面的數都比5大，所以5就排到最後了
同理，第二次排序，仍然從第一個數30開始比較，分別跟40,33交換了順序，比到10的時候，30比10大，所以30就停在了第三個位置，再用10去比較，10只比5大，所以排在了倒數第二個位置
依次10次比較後，得到最終排序結果
Java實現冒泡排序代碼如下，代碼實現過程，用一個臨時變量來做中間值，從而實現交換：
1 package maopaopaixu;
2
3 import java.util.Scanner; //使用到了scanner函數，所以需要導包
4
5 public class maopao {
6
7 public static void main(String[] args) {
8 int i,j,k,temp; //聲明變量
9 int a[]=new int[10]; //定義一個數組，長度為10
10 Scanner sc=new Scanner(System.in); //創建一個輸入對象
11 System.out.println("請輸入十個正整數："); //輸出
12 for(i=0;i<a.length;i++){ //使用for循環把數據存儲到數組中
13 a[i]=sc.nextInt();
14 }
15 for(j=0;j<a.length;j++){ //外層循環控制排序趟數
16 for(k=0;k<a.length-1;k++){ //內層循環控制每一趟排序多少次
17 if(a[k]<a[k+1]){ //取相鄰兩個數進行比較
18 temp=a[k+1]; //條件為真，進行交換位置，采用temp臨時變量
19 a[k+1]=a[k];
20 a[k]=temp;
21 }
22 }
23 }
24 for(i=0;i<a.length;i++){ //使用for循環，把排序的結果依次顯示
25 System.out.print(a[i]+"\t");
26 }
27
28 }
29
30 }
加上一些代碼可以看的更清晰，如下所示：
1 package maopaopaixu;
2
3 import java.util.Scanner; //使用到了scanner函數，所以需要導包
4
5 public class maopao {
6
7 public static void main(String[] args) {
8 int i,j,k,temp; //聲明變量
9 int a[]=new int[10]; //定義一個數組，長度為10
10 Scanner sc=new Scanner(System.in); //創建一個輸入對象
11 System.out.println("請輸入十個正整數："); //輸出
12 for(i=0;i<a.length;i++){ //使用for循環把數據存儲到數組中
13 a[i]=sc.nextInt();
14 }
15 for(j=0;j<a.length;j++){ //外層循環控制排序趟數
16 for(k=0;k<a.length-1;k++){ //內層循環控制每一趟排序多少次
17 if(a[k]<a[k+1]){ //取相鄰兩個數進行比較
18 temp=a[k+1]; //條件為真，進行交換位置，采用temp臨時變量
19 a[k+1]=a[k];
20 a[k]=temp;
21 }
22 }
23 System.out.print("第"+(j+1)+"次排序為："); //輸出
24 for(i=0;i<a.length;i++){ //在外層循環中看每一次排序後的結果
25 System.out.print(a[i]+"\t");
26 }
27 System.out.println(); //換行
28 }
29 System.out.print("最終排序為："); //輸出
30 for(i=0;i<a.length;i++){ //使用for循環，把排序的結果依次顯示
31 System.out.print(a[i]+"\t");
32 }
33
34 }
35
36 }
Java實現選擇排序法
基本思想為每一趟從待排序的數據元素中選擇最小（或最大）的一個元素作為首元素，直到所有元素排完為止，簡單選擇排序是不穩定排序。
在算法實現時，每一趟確定最小（或最大）元素的時候會通過不斷地比較交換來使得首位置為當前最小（或最大），交換是個比較耗時的操作。其實我們很容易發現，在還未完全確定當前最小（或最大）元素之前，這些交換都是無意義的。我們可以通過設置一個變量min（或max），每一次比較僅存儲較小（或較大）元素的數組下標，當輪循環結束之後，那這個變量存儲的就是當前最小（或最大）元素的下標，此時再執行交換操作即可。
簡言之，就是找到一組數中的最大值與第一個數交換順序
先看一張結果圖，一看就明白：
輸入的數據為：10, 35 67 88 99 100 2 34 77 55，我們可以從上圖看出，進行第一次排序時，只是最大值100與最小值10交換了位置，其他數的位置都沒有變化
同理，第二次就是該組數中的第二大的數99與第二小的數35交換位置，其他數位置不變
十次下來，就實現了排序功能
Java實現選擇排序代碼如下：
1 package xuanzepaixu;
2
3 import java.util.Scanner; //使用到了scanner函數，所以需要導包
4 /*選擇比較是找出最大的與第一個交換*/
5 public class xuanze {
6
7 public static void main(String[] args) {
8 int i,j,k,temp,max,count=0; //聲明變量
9 int a[] = new int[10]; //定義一個數組，長度為10
10 Scanner sc=new Scanner(System.in); //創建一個輸入對象
11 System.out.println("請輸入十個正整數："); //輸出
12 for(i=0;i<a.length;i++){ //使用for循環把數據存儲到數組中
13 a[i]=sc.nextInt();
14 }
15 for(j=0;j<a.length;j++){ //外層循環控制排序趟數
16 max=a[j]; //把數組中第j個值賦給max
17 count=j; //count記錄下標，若if結果為假，則保持原樣交換
18 for(k=j;k<a.length;k++){ //內層循環控制每一趟排序多少次
19 if(max<a[k]){ //假定的max值與數組依次去比較
20 max=a[k]; //為真就把a[k]的值賦給max
21 count=k; //count是記錄數的位置
22 }
23 }
24 temp=a[j]; //在外循環中對數據進行交換順序
25 a[j]=a[count];
26 a[count]=temp;
27 }
28 for(i=0;i<a.length;i++){ //使用for循環，把排序的結果依次顯示
29 System.out.print(a[i]+"\t");
30 }
31
32 }
33
34 }
選擇排序有個地方需要註意：就是count=j，若沒有這句，當出現判斷條件為假時，從而會導致整個排序出錯
加上顯示排序次數的代碼更加清楚，如下所示：
package xuanzepaixu;
import java.util.Scanner; //使用到了scanner函數，所以需要導包
/*選擇比較是找出最大的與第一個交換*/
public class xuanze {
public static void main(String[] args) {
int i,j,k,temp,max,count=0; //聲明變量
int a[] = new int[10]; //定義一個數組，長度為10
Scanner sc=new Scanner(System.in); //創建一個輸入對象
System.out.println("請輸入十個正整數："); //輸出
for(i=0;i<a.length;i++){ //使用for循環把數據存儲到數組中
a[i]=sc.nextInt();
}
for(j=0;j<a.length;j++){ //外層循環控制排序趟數
max=a[j]; //把數組中第j個值賦給max
count=j; //count記錄下標，若if結果為假，則保持原樣交換
for(k=j;k<a.length;k++){ //內層循環控制每一趟排序多少次
if(max<a[k]){ //假定的max值與數組依次去比較
max=a[k]; //為真就把a[k]的值賦給max
count=k; //count是記錄數的位置
}
}
temp=a[j]; //在外循環中對數據進行交換順序
a[j]=a[count];
a[count]=temp;
System.out.print("第"+(j+1)+"次排序為："); //輸出
for(i=0;i<a.length;i++){ //在外層循環中看每一次排序後的結果
System.out.print(a[i]+"\t");
}
System.out.println(); //換行
}
System.out.print("最後排序為："); //輸出
for(i=0;i<a.length;i++){ //使用for循環，把排序的結果依次顯示
System.out.print(a[i]+"\t");
}
}
}
C語言實現冒泡排序
實現原理都一樣，只是代碼寫法稍有不同罷了，所以就直接上代碼了：
1 #include<stdio.h>
2 main()
3 {
4 int i,j,temp;
5 int a[10];
6
7 printf("請輸入十個數：");
8 for(i=0;i<10;i++)
9 {
10 scanf("%d",&a[i]);
11 }
12
13
14 for(i=0;i<10;i++)
15 {
16 for(j=0;j<9-i;j++)
17 {
18 if(a[j]>a[j+1])
19 {
20 temp=a[j];
21 a[j]=a[j+1];
22 a[j+1]=temp;
23 }
24 }
25 }
26
27 for(i=0;i<10;i++)
28 {
29 printf("a[%d]=%d\n",i,a[i]);
30 }
31 }
C語言實現選擇排序
1 #include<stdio.h>
2
3 main()
4 {
5 int a[5],b,i,j,max,temp,count=0;
6
7 printf("請輸入五個數：");
8 for(i=0;i<5;i++)
9 {
10 scanf("%d",&a[i]);
11 }
12
13 for(i=0;i<4;i++)
14 {
15 count=i;
16 for(j=0;j<4-i;j++)
17 {
18 max=a[j];
19 if(max < a[j+1])
20 {
21 max=a[j+1];
22 b=j+1;
23 temp=a[j];
24 a[j]=a[j+1];
25 a[j+1]=temp;
26 }
27 }
28 }
29
30 for(i=0;i<5;i++)
31 {
32 printf("%d\n",a[i]);
33 }
34
35 printf("最大值為：%d",max);
36 }
本文僅代表作者觀點，系作者@溫一壺清酒發表。轉載請註明出處：http://www.cnblogs.com/hong-fithing/
使用C語言和Java分別實現冒泡排序和選擇排序