冒泡排序与选择拍序

写这篇博客纯粹为了更好的掌握知识！

冒泡排序是相邻的两个数进行比较，如果是升序排列就是把大的往后靠，这种算法思路很简单，但是有一些细节需要注意，线上代码吧：

1. #include <stdio.h>  
2.   
3. int main(void)  
4. {  
5.     
6.     int a[10] = {10,10,2,35,48,92,6,7,8,2};  
7.     
8.     int temp = 0,i,j;  
9.     //控制比较的次数（十个数实质上只需要将九个排出来，答案就出来了）  
10.     for(i=0;i<9;i++)  
11.     {  
12.         //每一个数比较的轮数  
13.         for(j=0;j<10-i-1;j++)  
14.         {  
15.             //前大于后 >升序  <降序  
16.             if(a[j]>a[j+1])  
17.             {  
18.                 
19.                 temp = a[j];  
20.                 a[j] = a[j+1];  
21.                 a[j+1]=temp;  
22.             }             
23.         }         
24.     }  
25.       
26.     for(int i=0;i<10;i++)  
27.     {  
28.         printf("a[%d]=%d\n",i,a[i]);  
29.     }  
30.       
31.       
32.     return 0;  
33. }  

选择排序与冒泡排序略有不同：比如书十个数字排序，它先找出十个数中最大的，然后放在第一位，然后再找后面九个数最大的，放在第二位，依次这样进行，上代码：

1. #include <stdio.h>  
2.   
3. int main(void)  
4. {  
5.     
6.          int a[10] = {100,3,23,9,108,56,1,24,52,0};  
7.     /* 
8.     1.先假定第一个数是最小的数，然后开始循环 
9.        从前往后取比较，找到最小的数，然后他们交换。        
10.      */  
11.   
12.          int i,j,temp,min;  
13.       
14.          for(i=0;i<9;i++)//次数  （这里同冒泡排序一样，不需要把第十个数也拿来比较）
15.     {  
16.         //轮数 每次选择假定最小的数  
17.         min = i;  
18.         for(j=i+1;j<10;j++)  
19.         {  
20.              if(a[min]>a[j])  
21.             {  
22.                       temp = a[i];    
23.                 /*把内层循环中找到,最小值交换给 
24.                       a[i];*/          
25.                       a[i] = a[j];  
26.                 a[j] = temp;  
27.             }  
28.         }         
29.     }  
30.       
31.       
32.     for(int i=0;i<10;i++)  
33.     {  
34.         printf("%d\n",a[i]);  
35.     }  
36.       
37.     return 0;  
38. }