简单的排序算法

 1 //选择排序
 2 void selectSort(int *ary, int len){
 3     int min = 0;
 4     for(int i = 0; i 1; i++){
 5         min = i;
 6         for(int j=i+1; j ){
 7             if(ary[min] > ary[j]){
 8                 min = j;//保存最小元素的位置
 9             }
10         }
11         //判断是否需要交换
12         if(min != i){
13             //找到了新的最小值
14             int tmp = ary[min];
15             arr[min] = ary[i];
16             ary[i] = tmp;
17         }
18     }
19 }

 1 //冒泡排序
 2 void bubbleSort(int *ary, int len)
 3 {
 4 #if 0
 5     for(int i = 0; i ){
 6         for(int j = 1; j ){
 7             if(ary[j] 1]){
 8                 int tmp = ary[j];
 9                 ary[j] = ary[j-1];
10                 ary[j-1] = tmp;
11             }
12         }
13     }
14 #if 1
15     //冒泡的优化
16     int flag = 0;//0:没有排好；1：排好
17     for(int i = len-1; i > 0 && flag==0; --i){
18         flag = 1;//默认已经排好
19         for(int j = 0; j j){ 
20             if(ary[j] > ary[j+1]){
21                 int tmp = ary[j];
22                 ary[j] = ary[j+1];
23                 ary[j+1] = tmp;
24                 flag = 0;//没有排好
25             }
26         }
27     }
28 }

 1 //插入排序
 2  void insertSort(int* ary, int len)
 3  {
 4      int tmp = 0; //存储基准数
 5      int index = 0; //坑的位置
 6      //遍历无序序列
 7      for(int i = 1; i ){
 8          index = i;
 9          tmp = ary[i];
10          //遍历有序序列(从后往前)
11          for(int j = i-1; j >=0; j--){
12              //基准数跟有序序列中的元素比较
13              if(tmp  ary[j]){
14                  //有序序列元素后移
15                  ary[j+1] = ary[j];
16                  //坑的位置
17                  index = j;
18              }
19              else{
20                  break;
21              }
22          }
23          //填坑
24          ary[index] = tmp;
25      }
26  }

 1 //希尔排序
 2 void shellSort(int* ary, int len)
 3 {
 4     //步长
 5     int gap = len;
 6     while(gap > 1){
 7         //步长递减公式
 8         gap = gap / 3 + 1;
 9         //分组，对每一组进行插入排序
10         for(int i = 0; i ){
11             //插入排序
12             int tmp;//基准数
13             int index;//坑的位置
14             //无序序列
15             for(int j = i+gap; j  gap){
16                 tmp = ary[j];
17                 index = j;
18                 //有序序列(从后往前)
19                 for(int k = j-gap; k>=0; k-=gap){
20                     if(tmp  ary[k]){
21                         //后移
22                         ary[k+gap] = ary[k];
23                         //位置
24                         index = k;
25                     }
26                     else{
27                         break;
28                     }
29                 }
30                 //填坑
31                 ary[index] = tmp;
32             }
33         }
34     }
35 }

 1 //快速排序 = 挖坑填数 + 分治法
 2 void quickSort(int s[], int l, int r)
 3 {
 4     //递归结束条件
 5     if(l>=r){return;}
 6     int i = l;//开始位置
 7     int j = r;//最后一个元素的位置
 8     int tmp = s[l]; //取第一个元素为基准数，i的位置为坑
 9     //需要循环判断
10     while(ij){
11         //j位置元素，大于等于基准数
12         while(i= tmp){
13             //前移
14             j--;
15         }
16         //找到了填坑的数
17         if(i  j){
18             a[i] = s[j]; //填坑, 此时j的位置变为坑
19             i++; //i后移
20         }
21         //移动i，j为坑
22         while(i tmp){
23             i++;//i后移
24         }
25         if(ij){
26             s[j] = s[i];//填坑，此时i的位置变为坑
27             j--;
28         }
29     }
30     //i=j
31     s[i] = tmp;//填坑
32     //拆分左半部分
33     quickSort(s, l, i-1);
34     //拆分右半部分
35     quickSort(s, i+1, r);
36 }