排序算法总结

1.         选择排序算法

            选择排序算法是从未排序的数据中选出最小的一个元素顺序放在已经排好序的数列最后。设有n个数，可经n-1趟选择排序后得到有序结果。首先把数据看作从1~n的无序区，有序区为空，然后从无序区中选出最小的数i，将它与无序区的第一个数进行交换，使它与后面的数分别变为新的有序区和无序区。再次从无序区中选出最小的数x，继续交换，直到无序区为空。

  1 //选择排序算法
  2 #include<stdio.h>
  3 int main()
  4 {
  5         int a[10];
  6         int i,j,k,m;
  7         printf("请输入10个数字，数字之间用空格隔开！\n");
  8         for(i=0;i<10;i++)
  9                 scanf("%d",&a[i]);
 10         for(i=0;i<9;i++)
 11         {
 12                 k=i;
 13                 for(j=i+1;j<10;j++)
 14                 {
 15                         if(a[k]>a[j])
 16                                 k=j;
 17                 }
 18                 if(k!=i)
 19                 {
 20                         m=a[i];
 21                         a[i]=a[k];
 22                         a[k]=m;
 23                 }
 24         }
 25         printf("用选择法从小到大排序后为:\n");
 26         for(i=0;i<10;i++)
 27                 printf("%d ",a[i]);
 28         printf("\n");
 29         return 0;
 30 }

2.         冒泡排序算法

             冒泡排序算法的思路是将相邻的两个数进行比较，小的放在前面，大的放在后面。先比较第1个数和第2个数，小数放前大数放后；然后再比较第2个数和第3个数，小数放前大数放后；以此类推直到最后两个数进行比较。重复上述过程，直至排序我完成。

  1 //冒泡排序算法
  2 #include<stdio.h>
  3 int main()
  4 {
  5         int a[10];
  6         int i,j,k;
  7         printf("请输入10个数，以空格隔开！\n");
  8         for(i=0;i<10;i++)
  9                 scanf("%d",&a[i]);
 10         for(i=0;i<9;i++)
 11         {
 12                 for(j=0;j<9-i;j++)
 13                         if(a[j]>a[j+1])
 14                         {
 15                                 k=a[j];
 16                                 a[j]=a[j+1];
 17                                 a[j+1]=k;
 18                         }
 19         }
 20         printf("你输入的数字按冒泡法由小到大排序后为：\n");
 21         for(i=0;i<10;i++)
 22                 printf("%d ",a[i]);
 23         printf("\n");
 24         return 0;
 25 }

3.          直接插入排序算法

             直接插入排序算法是把一个记录插入到已经排好序的有序序列中，使整个序列在插入了该记录后仍然有序。插入排序中较简单的一种方法就是直接插入排序，它插入位置的确定是通过将待插入的记录与有序区中的各记录自右向左依次比较其关键字值的大小来确定的。

  1 //直接插入排序算法
  2 #include<stdio.h>
  3 void insort(int s[],int n)
  4 {
  5         int i,j;
  6         for(i=2;i<=n;i++)//数组下标从2开始，0做监视哨，如果下标从1开始，一个数据没有可比性
  7         {
  8                 s[0]=s[i];//给监视哨赋值
  9                 j=i-1;
 10                 while(s[0]<s[j])
 11                 {
 12                         s[j+1]=s[j];//数据右移
 13                         j--;//移向右边一个未比较的数
 14                 }
 15                 s[j+1]=s[0];//在确定的位置插入s[i]
 16         }
 17 }
 18 int main()
 19 {
 20         int a[11],i;
 21         printf("请输入数字，以空格隔开:\n");
 22         for(i=1;i<=10;i++)
 23                 scanf("%d",&a[i]);
 24         insort(a,10);
 25         printf("你输入的数字按直接插入法由小到大排序为：\n");
 26         for(i=1;i<=10;i++)
 27                 printf("%5d",a[i]);
 28         printf("\n");
 29         return 0;
 30 }

4.         归并排序算法

             归并是将两个或多个有序记录序列合并成一个有序序列。归并方法有多种，一次对两个有序记录序列进行归并，称为二路归并排序，也有三路归并排序及多路归并排序。本实例是二路归并排序。基本方法如下：(1)将n个记录看成是n个长度为1的有序子表；(2)将两两相邻的有序子表进行归并；(3)重复执行步骤(2)，直到归并成一个长度为n有序表。

  1 //归并排序算法
  2 #include<stdio.h>
  3 //实现一次归并排序
  4 void merge(int r[],int s[],int x1,int x2,int x3)
  5 {
  6         int i,j,k;
  7         i=x1;//第一部分的开始位置
  8         j=x2+1;//第二部分的开始位置
  9         k=x1;
 10         while(i<=x2&&j<=x3)//i和j都在两个要合并的部分中
 11         {
 12                 if(r[i]<r[j])//筛选两部分中较小的元素放在数组s中
 13                 {
 14                         s[k]=r[i];
 15                         i++;
 16                         k++;
 17                 }
 18                 else
 19                 {
 20                         s[k]=r[j];
 21                         j++;
 22                         k++;
 23                 }
 24         }
 25         while(i<=x2)
 26                 s[k++]=r[i++];
 27         while(j<=x3)
 28                 s[k++]=r[j++];
 29 }
 30 //归并排序
 31 void merge_sort(int r[],int s[],int m,int n)
 32 {
 33         int p;
 34         int t[20];
 35         if(m==n)
 36                 s[m]=r[m];
 37         else
 38         {
 39                 p=(m+n)/2;
 40                 merge_sort(r,t,m,p);
 41                 merge_sort(r,t,p+1,n);
 42                 merge(t,s,m,p,n);
 43         }
 44 }
 45 int main()
 46 {
 47         int a[11];
 48         int i;
 49         printf("请输入8个数字，以空格分割：\n");
 50         for(i=1;i<=8;i++)
 51                 scanf("%d",&a[i]);
 52         merge_sort(a,a,1,8);
 53         printf("你输入的数字按归并法由小到大排序后为：\n");
 54         for(i=1;i<=8;i++)
 55                 printf("%5d",a[i]);
 56         printf("\n");
 57         return 0;
 58 }

5.          希尔排序算法

              希尔排序算法也是插入排序算法的一种，是针对直接插入排序算法的改进。该算法又称为缩小增量排序算法。

  1 //希尔排序算法
  2 #include<stdio.h>
  3 int main()
  4 {
  5         int a[10];
  6         int i,j,k,t;
  7         k=5;
  8         printf("请输入10个数，数字之间以空格隔开！\n");
  9         for(i=0;i<10;i++)
 10                 scanf("%d",&a[i]);
 11         while(k)
 12         {
 13                 for(i=k;i<10;i++)
 14                 {
 15                         j=i-k;
 16                         while(j>=0)
 17                         {
 18                                 if(a[j]>a[j+k])
 19                                 {
 20                                         t=a[j];
 21                                         a[j]=a[j+k];
 22                                         a[j+k]=t;
 23                                 }
 24                                 else
 25                                         break;
 26                         }
 27                 }
 28                 k/=2;
 29         }
 30         printf("你输入的数字按希尔排序算法由小到大排序为：\n");
 31         for(i=0;i<10;i++)
 32                 printf("%5d",a[i]);
 33         printf("\n");
 34         return 0;
 35 }

6.         快速排序算法

             快速排序算法是对冒泡排序算法的一种改进，它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据要小，然后再按此方法对这两部分数据分别进行快速排序，整个过程可以递归进行，直到整个数据变成有序序列。具体步骤如下：

            (1) 设置两个变量i，j，排序开始时，i=0，j=n-1；

            (2) 以第一个数组元素作为关键数据，赋值给key；

            (3) 从j开始向前搜索即由后开始向前搜索(j=j-1)，找到第一个小于key的值a[j]并与a[i]交换；

            (4) 从i开始向后搜索即由前开始向后搜索(i=i+1)，找到第一个大于key的值a[i]并与a[j]交换；

            (5) 重复步骤(3)~(5)，直到i=j为止。

  1 //快速排序算法
  2 #include<stdio.h>
  3 int p(int a[],int low,int high)
  4 {
  5         int key=a[low];
  6         int p;
  7         while(low<high)
  8         {
  9                 while(low<high&&a[high]>=key)
 10                         --high;
 11                 p=a[low];
 12                 a[low]=a[high];
 13                 a[high]=p;
 14                 while(low<high&&a[low]<=key)
 15                         ++low;
 16                 p=a[high];
 17                 a[high]=a[low];
 18                 a[low]=p;
 19         }
 20         a[low]=key;
 21         return low;
 22 }
 23 void q(int a[],int low,int high)
 24 {
 25         int j;
 26         if(low<high)
 27         {
 28                 j=p(a,low,high);
 29                 q(a,low,j-1);
 30                 q(a,j+1,high);
 31         }
 32 }
 33 int main()
 34 {
 35         int a[10];
 36         int i;
 37         printf("请输入10个数，数字之间以空格隔开！\n");
 38         for(i=0;i<10;i++)
 39                 scanf("%d",&a[i]);
 40         q(a,0,9);
 41         printf("你输入的数字按快速排序法由小到大排序为：\n");
 42         for(i=0;i<10;i++)
 43                 printf("%5d",a[i]);
 44         printf("\n");
 45         return 0;
 46 }