c语言实现几种排序算法

C语言 专栏收录该内容
7 篇文章 0 订阅

常见排序算法(冒泡,选择,快速)的C语言实现

冒泡法(起泡法)

 算法要求:用起泡法对10个整数按升序排序。

    算法分析:如果有n个数,则要进行n-1趟比较。在第1趟比较中要进行n-1次相邻元素的两两比较,在第j趟比较中要进行n-j次两两比较。比较的顺序从前往后,经过一趟比较后,将最值沉底(换到最后一个元素位置),最大值沉底为升序,最小值沉底为降序。

    算法源代码

# include <stdio.h>

main()

{

  int a[10],i,j,t;

  printf("Please input 10numbers: ");

  /*输入源数据*/

  for(i=0;i<10;i++)

    scanf("%d",&a[i]);

  /*排序*/

  for(i=0;i<9;i++)        /*外循环控制排序趟数,n个数排n-1*/

    for(j=0;j<9-i;j++)  /*内循环每趟比较的次数,第j趟比较n-j*/

      if(a[j]>a[j+1])   /*相邻元素比较,逆序则交换*/

      { t=a[j];

        a[j]=a[j+1];

        a[j+1]=t;

      }

  /*输出排序结果*/

  printf("The sortednumbers: ");

  for(i=0;i<10;i++)

    printf("%d   ",a[i]);

  printf("\n");

}

算法特点相邻元素两两比较,每趟将最值沉底即可确定一个数在结果的位置,确定元素位置的顺序是从后往前,其余元素可能作相对位置的调整。可以进行升序或降序排序。

算法分析:定义n-1次循环,每个数字比较n-j次,比较前一个数和后一个数的大小。然后交换顺序

选择法

    算法要求:用选择法对10个整数按降序排序。

    算法分析:每趟选出一个最值和无序序列的第一个数交换,n个数共选n-1趟。第i趟假设i为最值下标,然后将最值和i+1至最后一个数比较,找出最值的下标,若最值下标不为初设值,则将最值元素和下标为i的元素交换。

    算法源代码

# include <stdio.h>

main()

{

  int a[10],i,j,k,t,n=10;

  printf("Please input 10numbers:");

  for(i=0;i<10;i++)

   scanf("%d",&a[i]);

  for(i=0;i<n-1;i++)     /*外循环控制趟数,n个数选n-1*/

  {

    k=i;               /*假设当前趟的第一个数为最值,记在k */

    for(j=i+1;j<n;j++)  /*从下一个数到最后一个数之间找最值*/

    {

        if(a[k]<a[j])     /*若其后有比最值更大的*/

           k=j;           /*则将其下标记在k*/

     }                     /*切记先加{}完了才判断 if(k != k)*/

    if(k!=i)                     /*k不为最初的i值,说明在其后找到比其更大的数*/

    {  t=a[k]; a[k]=a[i];  a[i]=t;  } /*则交换最值和当前序列的第一个数*/

  }

  printf("The sortednumbers: ");

  for(i=0;i<10;i++)

    printf("%d   ",a[i]);

  printf("\n");

}

  算法特点:每趟是选出一个最值确定其在结果序列中的位置,确定元素的位置是从前往后,而每趟最多进行一次交换,其余元素的相对位置不变。可进行降序排序或升序排序。

  算法分析:定义外部n-1次循环,假设第一个为最值,放在参数中,在从下一个数以后找最值若后面有比前面假设的最值更大的就放在k中,然后在对k进行分析。若k部位最初的i值。也就是假设的i不是最值,那么就交换最值和当前序列的第一个数

插入法

    算法要求:用插入排序法对10个整数进行降序排序。

    算法分析:将序列分为有序序列和无序列,依次从无序序列中取出元素值插入到有序序列的合适位置。初始是有序序列中只有第一个数,其余n-1个数组成无序序列,则n个数需进n-1次插入。寻找在有序序列中插入位置可以从有序序列的最后一个数往前找,在未找到插入点之前可以同时向后移动元素,为插入元素准备空间。

    算法源代码

# include <stdio.h>

main()

{

  int a[10],i,j,t;

  printf("Please input 10numbers: ");

  for(i=0;i<10;i++)

  scanf("%d",&a[i]);

  for(i=1;i<10;i++)        /*外循环控制趟数,n个数从第2个数开始到最后共进行n-1次插入*/

  {

     t=a[i];                         /*将待插入数暂存于变量t*/

    for( j=i-1; j>=0; j-- )   /*在有序序列(下标0 ~ i-1)中寻找插入位置*/

    {

if( a[j]> t )  

a[j+1]=a[j];        /*若未找到插入位置,则当前元素后移一个位置*/

else

break;  /*找到插入的位置则退出当前循环*/

    }

     a[j+1]=t;            /*完成插入*/

  }

  printf("The sortednumbers: ");

  for(i=0;i<10;i++)

    printf("%d   ",a[i]);

  printf("\n");

 }


快速排序 
    快速法定义了三个参数,(数组首地址*a,要排序数组起始元素下标i,要排序数组结束元素下标j).
    它首先选一个数组元素(一般为a[ (i+j)/2 ],即中间元素)作为参照,把比它小的元素放到它的左边,比它大的放在右边。
    然后运用递归,在将它左,右两个子数组排序,最后完成整个数组的排序。
下面分析其代码: 
C语言版本:
void sort(int *a, int left, int right)
{
    if(left >= right)/*如果左边索引大于或者等于右边的索引就代表已经整理完成一个组了*/
    {
        return ;
    }
    int i = left;
    int j = right;
    int key = a[left];
     
    while(i < j)                               /*控制在当组内寻找一遍*/
    {
        while(i < j && key <= a[j])
        /*而寻找结束的条件就是,1,找到一个小于或者大于key的数(大于或小于取决于你想升
        序还是降序)2,没有符合条件1的,并且i与j的大小没有反转*/ 
        {
            j--;/*向前寻找*/
        }
         
        a[i] = a[j];
        /*找到一个这样的数后就把它赋给前面的被拿走的i的值(如果第一次循环且key是
        a[left],那么就是给key)*/
         
        while(i < j && key >= a[i])
        /*这是i在当组内向前寻找,同上,不过注意与key的大小关系停止循环和上面相反,
        因为排序思想是把数往两边扔,所以左右两边的数大小与key的关系相反*/
        {
            i++;
        }
         
        a[j] = a[i];
    }
     
    a[i] = key;/*当在当组内找完一遍以后就把中间数key回归*/
    sort(a, left, i - 1);/*最后用同样的方式对分出来的左边的小组进行同上的做法*/
    sort(a, i + 1, right);/*用同样的方式对分出来的右边的小组进行同上的做法*/
                       /*当然最后可能会出现很多分左右,直到每一组的i = j 为止*/
}
C++版本:
#include <iostream>
 
using namespace std;
 
void Qsort(int a[], int low, int high)
{
    if(low >= high)
    {
        return;
    }
    int first = low;
    int last = high;
    int key = a[first];/*用字表的第一个记录作为枢轴*/
 
    while(first < last)
    {
        while(first < last && a[last] >= key)
        {
            --last;
        }
 
        a[first] = a[last];/*将比第一个小的移到低端*/
 
        while(first < last && a[first] <= key)
        {
            ++first;
        }
         
        a[last] = a[first];    
/*将比第一个大的移到高端*/
    }
    a[first] = key;/*枢轴记录到位*/
    Qsort(a, low, first-1);
    Qsort(a, first+1, high);
}
int main()
{
    int a[] = {57, 68, 59, 52, 72, 28, 96, 33, 24};
 
    Qsort(a, 0, sizeof(a) / sizeof(a[0]) - 1);/*这里原文第三个参数要减1否则内存越界*/
 
    for(int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
    {
        cout << a[i] << "";
    }
     
    return 0;
}


交换2个数,异或来处理。

  a=a^b;  
  b=a^b;  
  a=a^b; 

或者

  a=a+b;  
  b=a-b;  
  a=a-b; 

冒泡排序  

基本概念

      冒泡排序(BubbleSort)的基本概念是:依次比较相邻的两个数,将小数放在前面,大数放在后面。即在第一趟:首先比较第1个和第2个数,将小数放前,大数放后。然后比较第2个数和第3个数,将小数放前,大数放后,如此继续,直至比较最后两个数,将小数放前,大数放后。至此第一趟结束,将最大的数放到了最后。在第二趟:仍从第一对数开始比较(因为可能由于第2个数和第3个数的交换,使得第1个数不再小于第2个数),将小数放前,大数放后,一直比较到倒数第二个数(倒数第一的位置上已经是最大的),第二趟结束,在倒数第二的位置上得到一个新的最大数(其实在整个数列中是第二大的数)。如此下去,重复以上过程,直至最终完成排序。

  由于在排序过程中总是小数往前放,大数往后放,相当于气泡往上升,所以称作冒泡排序。

  用二重循环实现,外循环变量设为i,内循环变量设为j。外循环重复9次,内循环依次重复9,8,...,1次。每次进行比较的两个元素都是与内循环j有关的,它们可以分别用a[j]和a[j+1]标识,i的值依次为1,2,...,9,对于每一个i, j的值依次为1,2,...10-i。

产生

  在许多程序设计中,我们需要将一个数列进行排序,以方便统计,而冒泡排序一直由于其简洁的思想方法而倍受青睐。

排序过程

  设想被排序的数组R[1..N]垂直竖立,将每个数据元素看作有重量的气泡,根据轻气泡不能在重气泡之下的原则,从下往上扫描数组R,凡扫描到违反本原则的轻气泡,就使其向上"漂浮",如此反复进行,直至最后任何两个气泡都是轻者在上,重者在下为止。

算法示例

A[0] 、 A[1]、 A[2]、 A[3]、 A[4]、 A[5]、 A[6]:

49 38 65 97 76 13 27

第一趟冒泡排序过程

38 49 65 97 76 13 27

38 49 65 97 76 13 27

38 49 65 97 76 13 27

38 49 65 76 97 13 27

38 49 65 76 13 97 27

38 49 65 76 13 27 97 – 这是第一趟冒泡排序完的结果

第二趟也是重复上面的过程,只不过不需要比较最后那个数97,因为它已经是最大的

38 49 65 13 27 76 97 – 这是结果

第三趟继续重复,但是不需要比较倒数2个数了

38 49 13 27 65 76 97

….

选择排序

基本思想

n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果:

初始状态:无序区为R[1..n],有序区为空

②第1趟排序

  在无序区R[1..n]中选出关键字最小的记录R[k],将它与无序区的第1个记录R[1]交换,使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

……

③第i趟排序

  第i趟排序开始时,当前有序区和无序区分别为R[1..i-1]和R(1≤i≤n-1)。该趟排序从当前无序区中选出关键字最小的记录 R[k],将它与无序区的第1个记录R交换,使R[1..i]和R分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

  这样,n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果。

  常见的选择排序细分为简单选择排序、树形选择排序(锦标赛排序)、堆排序。上述算法仅是简单选择排序的步骤。

排序过程

A[0] 、 A[1]、 A[2]、 A[3]、 A[4]、 A[5]、 A[6]:

49 38 65 97 76 13 27

  第一趟排序后 13 [38 65 97 76 49 27]

  第二趟排序后 13 27 [65 97 76 49 38]

  第三趟排序后 13 27 38 [97 76 49 65]

  第四趟排序后 13 27 38 49 [76 97 65]

  第五趟排序后 13 27 38 49 65 [97 76]

  第六趟排序后 13 27 38 49 65 76 [97]

最后排序结果 13 27 38 49 49 65 76 97

快速排序算法

算法过程

  设要排序的数组是A[0]……A[N-1],首先任意选取一个数据(通常选用第一个数据)作为关键数据,然后将所有比它小的数都放到它前面,所有比它大的数都放到它后面,这个过程称为一趟快速排序。一趟快速排序的算法是:

1)设置两个变量I、J,排序开始的时候:I=0,J=N-1;

2)以第一个数组元素作为关键数据,赋值给key,即 key=A[0];

3)从J开始向前搜索,即由后开始向前搜索(J=J-1),找到第一个小于key的值A[J],并与A[I]交换;

4)从I开始向后搜索,即由前开始向后搜索(I=I+1),找到第一个大于key的A[I],与A[J]交换;

5)重复第3、4、5步,直到 I=J; (3,4步是在程序中没找到时候j=j-1,i=i+1,直至找到为止。找到并交换的时候i, j指针位置不变。另外当i=j这过程一定正好是i+或j+完成的最后另循环结束)

  例如:待排序的数组A的值分别是:(初始关键数据:X=49) 注意关键X永远不变,永远是和X进行比较,无论在什么位子,最后的目的就是把X放在中间,小的放前面大的放后面。

A[0] 、 A[1]、 A[2]、 A[3]、 A[4]、 A[5]、 A[6]:

49 38 65 97 76 13 27

  进行第一次交换后: 27 38 65 97 76 13 49

( 按照算法的第三步从后面开始找)

  进行第二次交换后: 27 38 49 97 76 13 65

( 按照算法的第四步从前面开始找>X的值,65>49,两者交换,此时:I=3 )

  进行第三次交换后: 27 38 13 97 76 49 65

( 按照算法的第五步将又一次执行算法的第三步从后开始找

  进行第四次交换后: 27 38 13 49 76 97 65

( 按照算法的第四步从前面开始找大于X的值,97>49,两者交换,此时:I=4,J=6 )

  此时再执行第三步的时候就发现I=J,从而结束一趟快速排序,那么经过一趟快速排序之后的结果是:27 38 13 49 76 97 65,即所以大于49的数全部在49的后面,所以小于49的数全部在49的前面。

  快速排序就是递归调用此过程——在以49为中点分割这个数据序列,分别对前面一部分和后面一部分进行类似的快速排序,从而完成全部数据序列的快速排序,最后把此数据序列变成一个有序的序列,根据这种思想对于上述数组A的快速排序的全过程如图6所示:

  初始状态 {49 38 65 97 76 13 27}

  进行一次快速排序之后划分为 {27 38 13} 49 {76 97 65}

  分别对前后两部分进行快速排序 {27 38 13} 经第三步和第四步交换后变成 {13 27 38} 完成排序。

{76 97 65} 经第三步和第四步交换后变成 {65 76 97} 完成排序。

  • 0
    点赞
  • 0
    评论
  • 3
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

相关推荐
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值