1、C语言选择排序算法及代码
基本思想及举例说明
选择排序（从小到大）的基本思想是，首先，选出最小的数，放在第一个位置；然后，选出第二小的数，放在第二个位置；以此类推，直到所有的数从小到大排序。
在实现上，我们通常是先确定第i小的数所在的位置，然后，将其与第i个数进行交换。

下面给出选择排序的C语言实现。

  

1. #include<stdio.h>  
   
2.     #include<stdlib.h>  
   
3.     #define N 8  
   
4.     void select_sort(int a[],int n);  
   
5.     //选择排序实现  
   
6.     void select_sort(int a[],int n)//n为数组a的元素个数  
   
7.     {  
   
8.         //进行N-1轮选择  
   
9.         for(int i=0; i<n-1; i++)  
   
10.         {  
    
11.             int min_index = i;  
    
12.             //找出第i小的数所在的位置  
    
13.             for(int j=i+1; j<n; j++)  
    
14.             {  
    
15.                 if(a[j] < a[min_index])  
    
16.                 {  
    
17.                     min_index = j;  
    
18.                 }  
    
19.             }  
    
20.             //将第i小的数，放在第i个位置；如果刚好，就不用交换  
    
21.             if( i != min_index)  
    
22.             {  
    
23.                 int temp = a[i];  
    
24.                 a[i] = a[min_index];  
    
25.                 a[min_index] = temp;  
    
26.             }  
    
27.         }  
    
28.     }  
    
29.     int main()  
    
30.     {  
    
31.         int num[N] = {89, 38, 11, 78, 96, 44, 19, 25};  
    
32.         select_sort(num, N);  
    
33.         for(int i=0; i<N; i++)  
    
34.             printf("%d ", num[i]);  
    
35.         printf("\n");  
    
36.         system("pause");  
    
37.         return 0;  
    
38.     }  
    

复制代码

注意：选择排序是一种不稳定的排序算法，可能会打乱两个相同数字的原有顺序。
例如，序列 5  8  5  2  9， 按照从小到大排序，第一轮会将第1个数字5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序是一种不稳定的排序算法。

2、C语言冒泡排序算法及代码

基本思想及举例说明
冒泡排序的基本思想就是不断比较相邻的两个数，让较大的元素不断地往后移。经过一轮比较，就选出最大的数；经过第2轮比较，就选出次大的数，以此类推。

  

1. #include<stdio.h>  
   
2.     #include<stdlib.h>  
   
3.     #define N 8  
   
4.     void bubble_sort(int a[],int n);  
   
5.       
   
6.     //一般实现  
   
7.     void bubble_sort(int a[],int n)//n为数组a的元素个数  
   
8.     {  
   
9.         //一定进行N-1轮比较  
   
10.         for(int i=0; i<n-1; i++)  
    
11.         {  
    
12.             //每一轮比较前n-1-i个，即已排序好的最后i个不用比较  
    
13.             for(int j=0; j<n-1-i; j++)  
    
14.             {  
    
15.                 if(a[j] > a[j+1])  
    
16.                 {  
    
17.                     int temp = a[j];  
    
18.                     a[j] = a[j+1];  
    
19.                     a[j+1]=temp;  
    
20.                 }  
    
21.             }  
    
22.         }  
    
23.     }  
    
24.     //优化实现  
    
25.     void bubble_sort_better(int a[],int n)//n为数组a的元素个数  
    
26.     {  
    
27.         //最多进行N-1轮比较  
    
28.         for(int i=0; i<n-1; i++)  
    
29.         {  
    
30.             bool isSorted = true;  
    
31.             //每一轮比较前n-1-i个，即已排序好的最后i个不用比较  
    
32.             for(int j=0; j<n-1-i; j++)  
    
33.             {  
    
34.                 if(a[j] > a[j+1])  
    
35.                 {  
    
36.                     isSorted = false;  
    
37.                     int temp = a[j];  
    
38.                     a[j] = a[j+1];  
    
39.                     a[j+1]=temp;  
    
40.                 }  
    
41.             }  
    
42.             if(isSorted) break; //如果没有发生交换，说明数组已经排序好了  
    
43.         }  
    
44.     }  
    
45.     int main()  
    
46.     {  
    
47.         int num[N] = {89, 38, 11, 78, 96, 44, 19, 25};  
    
48.         bubble_sort(num, N); //或者使用bubble_sort_better(num, N);  
    
49.         for(int i=0; i<N; i++)  
    
50.             printf("%d ", num[i]);  
    
51.         printf("\n");  
    
52.         system("pause");  
    
53.         return 0;  
    
54.     }  
    
55. 
    

复制代码

3、C语言插入排序算法及代码

基本思想及举例说明
插入排序的基本思想是，将元素逐个添加到已经排序好的数组中去，同时要求，插入的元素必须在正确的位置，这样原来排序好的数组是仍然有序的。

在实际使用中，通常是排序整个无序数组，所以把这个无序数组分为两部分排序好的子数组和待插入的元素。第一轮时，将第一个元素作为排序好的子数组，插入第二个元素；第二轮，将前两个元素作为排序好的数组，插入第三个元素。以此类推，第i轮排序时，在前i个元素的子数组中插入第i+1个元素。直到所有元素都加入排序好数组。

下面，以对 3  2  4  1 进行选择排序说明插入过程，使用j记录元素需要插入的位置。排序目标是使数组从小到大排列。

第1轮
[ 3 ]  [ 2  4  1 ]  （最初状态，将第1个元素分为排序好的子数组，其余为待插入元素）
[ 3 ]  [ 2  4  1 ]  （由于3>2，所以待插入位置j=1）
[ 2  3 ]  [ 4  1 ]  （将2插入到位置j）

第2轮
[ 2  3 ]  [ 4  1 ] （第1轮排序结果）
[ 2  3 ]  [ 4  1 ] （由于2<4，所以先假定j=2）
[ 2  3 ]  [ 4  1 ] （由于3<4，所以j=3）
[ 2  3  4 ]  [ 1 ] （由于4刚好在位置3，无需插入）

第3轮
[ 2  3  4 ]  [ 1 ] （第2轮排序结果）
[ 2  3  4 ]  [ 1 ] （由于1<2，所以j=1）
[1  2  3  4 ]    （将1插入位置j，待排序元素为空，排序结束）
算法总结及实现
选择排序对大小为N的无序数组R[N]进行排序，进行N-1轮选择过程。首先将第1个元素作为已经排序好的子数组，然后将剩余的N-1个元素，逐个插入到已经排序好子数组；。因此，在第 i轮排序时，前i个元素总是有序的，将第i+1个元素插入到正确的位置。
  

1. #include<stdio.h>  
   
2.     #include<stdlib.h>  
   
3.     #define N 8  
   
4.     void insert_sort(int a[],int n);  
   
5.     //插入排序实现,这里按从小到大排序  
   
6.     void insert_sort(int a[],int n)//n为数组a的元素个数  
   
7.     {  
   
8.         //进行N-1轮插入过程  
   
9.         for(int i=1; i<n; i++)  
   
10.         {  
    
11.             //首先找到元素a[i]需要插入的位置  
    
12.             int j=0;  
    
13.             while( (a[j]<a[i]) && (j<i))  
    
14.             {  
    
15.                 j++;  
    
16.             }  
    
17.             //将元素插入到正确的位置  
    
18.             if(i != j) //如果i==j，说明a[i]刚好在正确的位置  
    
19.             {  
    
20.                 int temp = a[i];  
    
21.                 for(int k = i; k > j; k--)  
    
22.                 {  
    
23.                     a[k] = a[k-1];  
    
24.                 }  
    
25.                 a[j] = temp;  
    
26.             }  
    
27.         }  
    
28.     }  
    
29.     int main()  
    
30.     {  
    
31.         int num[N] = {89, 38, 11, 78, 96, 44, 19, 25};  
    
32.         insert_sort(num, N);  
    
33.         for(int i=0; i<N; i++)  
    
34.             printf("%d ", num[i]);  
    
35.         printf("\n");  
    
36.         system("pause");  
    
37.         return 0;  
    
38.     }  
    

复制代码

注意：插入排序是一种稳定的排序算法，不会改变原有序列中相同数字的顺序。

插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有1个元素，就是第一个元素。比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。

4、C语言二分查找（折半查找）算法及代码

二分査找也称折半査找，其优点是查找速度快，缺点是要求所要査找的数据必须是有序序列。该算法的基本思想是将所要査找的序列的中间位置的数据与所要査找的元素进行比较，如果相等，则表示査找成功，否则将以该位置为基准将所要査找的序列分为左右两部分。接下来根据所要査找序列的升降序规律及中间元素与所查找元素的大小关系，来选择所要査找元素可能存在的那部分序列，对其采用同样的方法进行査找，直至能够确定所要查找的元素是否存在，具体的使用方法可通过下面的代码具体了解。

  

1. #include <stdio.h>  
   
2.     binarySearch(int a[], int n, int key)  
   
3.     {  
   
4.         int low = 0;  
   
5.         int high = n - 1;  
   
6.         while(low<= high){  
   
7.             int mid = (low + high)/2;  
   
8.             int midVal = a[mid];  
   
9.             if(midVal<key)  
   
10.                 low = mid + 1;  
    
11.             else if(midVal>key)  
    
12.                 high = mid - 1;  
    
13.             else  
    
14.                 return mid;  
    
15.         }  
    
16.         return -1;  
    
17.     }  
    
18.     int main()  
    
19.     {  
    
20.         int i, val, ret;  
    
21.         int a[8]={-32, 12, 16, 24, 36, 45, 59, 98};  
    
22.         for(i=0; i<8; i++)  
    
23.             printf("%d\t", a[i]);  
    
24.         printf("\n请输人所要查找的元素：");  
    
25.         scanf("%d",&val);  
    
26.         ret = binarySearch(a,8,val);  
    
27.         if(-1 == ret)  
    
28.             printf("查找失败 \n");  
    
29.         else  
    
30.             printf ("查找成功 \n");  
    
31.         return 0;  
    
32.     }  
    
33.       

复制代码

    运行结果：  
      
    -32    12    16    24    36    45    59    98  
    请输入所要查找的元素：12  
    查找成功  

八错八错，算法中最常用的就是排序算法了

受教，收下学习了。