数据结构C语言版（李云清）实验10 排序

最新推荐文章于 2026-06-03 14:51:03 发布
原创 最新推荐文章于 2026-06-03 14:51:03 发布 · 4.2k 阅读 · 55 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#数据结构 #算法 #排序算法 #c语言
这篇博客详细介绍了如何使用C语言实现直接插入排序、二分插入排序、Shell排序、选择排序、堆排序、冒泡排序、快速排序、归并排序以及基于链表的基数排序，并对每种排序算法在不同数据规模下的效率进行了测试。

实验10 排序

1、请设计直接插入排序算法函数void insertSort(int a[],int n)，对a[1]…a[n]进行升序排序。并测试在不同数据规模下的排序效率。

#include "Arrayio.h"
#define N 500000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/

/*请将本函数补充完整，并进行测试*/
void insertSort(int a[],int n)
{   /*直接插入排序*/
    int i,j;
    for (i=2;i<=n;i++)
    {
        //每一趟将a[i]插入到a[1]..a[i-1]
        a[0]=a[i];
        j=i-1;
        while ( a[j] > a[0])
        {
            a[j+1]=a[j];
            j--;
        }
        a[j+1]=a[0];
    }
}

int  main()
{
  int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
  printf("数据初始化...\n");
  n=readData(a,N,"out.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
  printf("%d个数据排序中...\n",n);
  insertSort(a,n);
  saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
  output(a,10);
  printf("排序结束，排序结果保存在out.txt文件中。\n");
  return 0;
}

2、请设计二分插入排序算法函数void binInsertSort(int a[],int n)，对a[1]…a[n]进行升序排序。并测试在不同数据规模下的排序效率。

#include "Arrayio.h"
#define N 50000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/

/*请将本函数补充完整，并进行测试*/
void binInsertSort(int a[],int n)
{
    int mid,left,right,i,j;
    for (i=2;i<=n;i++)
    {
        left=1;
        right=i-1;
        while (left<=right)
        {
            mid=(left+right)/2;
            if (a[i]<a[mid])
                    right=mid-1;
            else
                    left=mid+1;
        }
        //插入的位置是left
        a[0]=a[i];
        for (j=i-1;j>=left;j--)
                a[j+1]=a[j];
        a[left]=a[0];
    }

}

int  main()
{
  int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
  printf("数据初始化...\n");
  n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
  printf("%d个数据排序中...\n",n);
  binInsertSort(a,n);
  saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
  output(a,n);
  printf("排序结束，排序结果保存在out.txt文件中。\n");
  return 0;
}

3、请设计shell排序算法函数void shellSort(int a[],int n)，对a[1]…a[n]进行升序排序。并测试在不同数据规模下的排序效率。

#include "Arrayio.h"
#define N 500000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/

/*请将本函数补充完整，并进行测试*/
void shellSort(int a[],int n)
{
    int i,j,d;
    d=n/2;
    while (d>=1)
    {
           for (i=d+1;i<=n;i++)
            {
                //每一趟将a[i]插入到a[1]..a[i-1]
                a[0]=a[i];
                j=i-d;
                while ( j>=1 &&a[j] > a[0])
                {
                    a[j+d]=a[j];
                    j=j-d;
                }
                a[j+d]=a[0];
            }

    d=d/2;
    }

}

int  main()
{
  int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
  printf("数据初始化...\n");
  n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
  printf("%d个数据排序中...\n",n);
  shellSort(a,n);
  saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
  printf("排序结束，排序结果保存在out.txt文件中。\n");
  return 0;
}

4、请设计简单选择排序算法函数void selectSort(int a[],int n)，对a[1]…a[n]进行升序排序。并测试在不同数据规模下的排序效率。

#include "Arrayio.h"
#define N 50     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/

/*请将本函数补充完整，并进行测试*/
void selectSort(int a[],int n)
{
    int i,j,max;
    for (i=1;i<n;i++)
    {
        max=i;
        for (j=i+1;j<=n;j++)
                if (a[j]>a[max])
                    max=j;
        if (max!=i)
        {
            a[0]=a[i];
            a[i]=a[max];
            a[max]=a[0];
        }
    }
}

int  main()
{
  int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
  printf("数据初始化...\n");
  n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
  printf("%d个数据排序中...\n",n);
  selectSort(a,n);
  saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
  printf("排序结束，排序结果保存在out.txt文件中。\n");
  return 0;
}

5、请设计筛选函数void sift(int a[],int k,int n)，对a[k] 进行筛选，并利用其设计堆排序算法函数void heapSort(int a[],int n)，对a[1]…a[n]进行升序排序。并测试在不同数据规模下的排序效率。

#include "Arrayio.h"
#define N 500     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/

/*请将本函数补充完整，并进行测试*/
void sift(int a[],int k,int n)
{
      int i,j,finished;
      i=k;
      j=2*i;
      a[0]=a[k];
      finished=0;
      while((j<=n)&&(!finished))
      {
        if((j<n)&&(a[j+1]>a[j]))
             j++;
        if(a[0]>=a[j])
             finished=1;
        else
        {
          a[i]=a[j];
          i=j;
          j=2*j;
        }
      }
      a[i]=a[0];
    }

void heapSort(int a[],int n)
{
    int i;
    for (i=n/2;i>=1;i--)
        sift(a,i,n);
    for (i=n;i>1;i--)
        {
            a[0]=a[i];
            a[i]=a[1];
            a[1]=a[0];
            sift(a,1,i-1);
        }
}

int  main()
{
  int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
  printf("数据初始化...\n");
  n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
  printf("%d个数据排序中...\n",n);
  heapSort(a,n);
  saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
  printf("排序结束，排序结果保存在out.txt文件中。\n");
  return 0;
}

6、请设计冒泡排序算法函数void bubbleSort(int a[],int n)，对a[1]…a[n]进行升序排序。并测试在不同数据规模下的排序效率。

#include "Arrayio.h"
#define N 50   /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/

/*请将本函数补充完整，并进行测试*/
void bubbleSort(int a[],int n)
{
    int i;
    int flag=1;
    while (n>1 && flag==1)
    {  flag=0;
        for (i=1;i<n;i++)
        {      if (a[i]>a[i+1])
                {      a[0]=a[i];
                        a[i]=a[i+1];
                        a[i+1]=a[0];
                        flag=1;
                }
        }
        n--;
    }
}

int  main()
{
  int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
  printf("数据初始化...\n");
  n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
  printf("%d个数据排序中...\n",n);
  bubbleSort(a,n);
 // output(a,n);
  saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
  printf("排序结束，排序结果保存在out.txt文件中。\n");
  return 0;
}

7、请设计快速排序算法函数void quickSort(int a[],int low,int high)，对a[low]…a[high]进行升序排序。并测试在不同数据规模下的排序效率。

#include "Arrayio.h"
#define N 500000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/

/*请将本函数补充完整，并进行测试*/
void quickSort(int a[],int low,int high )
{
    int left,right;
    if (low<high)
    {
        left=low;
        right=high;
        a[0]=a[low];
        do
        {//来加比较法的一次划分
                while (left<right && a[right]>a[0])
                        right--;
                if (left<right)
                        a[left++]=a[right];
                while (left<right &&a[left]<=a[0])
                        left++;
                if (left<right)
                        a[right--]=a[left];
        }while (left!=right);
        a[left]=a[0];
        quickSort(a,low,left-1);
        quickSort(a,left+1,high);
    }
}

int  main()
{
  int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
  printf("数据初始化...\n");
  n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
  printf("%d个数据排序中...\n",n);

  quickSort(a,1,n);

  saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
  printf("排序结束，排序结果保存在out.txt文件中。\n");
  return 0;
}

8、请设计归并排序算法函数void mergeSort(int a[],int n)，对a[1]…a[n]进行升序排序。并测试在不同数据规模下的排序效率。

#include "Arrayio.h"
#define N 10000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/

/*请将本函数补充完整，并进行测试*/

void merge(int a[],int u,int m,int v)
{ /*将有序段a[u..m],a[m+1..v]归并到a[u..v]*/

    int i,j,k,t;
    int b[N+1];
    i=u; j=m+1; k=u;
    while (i<=m && j<=v)
    {  if (a[i]<=b[j] )
        {           b[k]=a[i];
                    i++;
       }
       else
       {            b[k]=a[j];
                    j++;
       }
       k++;
    }
  if (i>m)
      for (t=j;t<=v;t++)
                b[k+t-j]=a[t];
  else
      for (t=i;t<=m;t++)
                b[k+t-i]=a[t];
  /*将l2表中的内容拷贝回表l1*/
  for (i=u;i<=v;i++)
                a[i]=b[i];
}
/*----一趟归并------*/
 int  mergepass(int a[],int n,int len)
  { /*对a[1..n]进行长度为len的一趟并归*/
    int i,t;
    i=1;
    while (i<=n-2*len+1)
      {         merge(a,i,i+len-1,i+2*len-1);
                i=i+2*len;
      }

    if (i+len-1<n)
            merge(a,i,i+len-1,n);
 }

/*----归并排序------*/
void mergeSort(int a[],int n)
{   int  len, b[N+1];
    len=1;
    while (len<n)
      {     mergepass(a,n,len);
             len=len*2;
      }
}
/*归并排序的递归实现*/
void mergeSortdc(int a[],int low,int high)
{
    int mid;
    if (low<high)
    {
        mid=(low+high)/2;
        mergeSortdc(a,low,mid);
        mergeSortdc(a,mid+1,high);
        merge(a,low,mid,high);
    }
}

int  main()
{
  int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
  printf("数据初始化...\n");
  n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
  printf("%d个数据排序中...\n",n);
  mergeSort(a,n);                   /* 或调用mergeSortdc(a,1,n); */
  //mergeSortdc(a,1,n);
  saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
  printf("排序结束，排序结果保存在out.txt文件中。\n");
  return 0;
}

9、请设计基于链表的基数排序函数void radixSort(linklist head)，对带头结点的整型非负单链表进行升序排序。并测试在不同数据规模下的排序效率。(注：链表中的最大整数为500000)

#include "slnklist.h"
#define N 500000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/
struct  node2
{
    linklist front,rear;
};
/*请将本函数补充完整，并进行测试*/
void radixSort(linklist head)
{
    struct node2 q[10];/*队列*/
    linklist  p,r;
    int i,j,k,x;
    for (j=0;j<10;j++)
            q[j].rear=q[j].front=NULL;
    for (i=0;i<6;i++)  //排序的最大数为6位数，共进行6趟分配收集过程
    {
        p=head->next;       //分配
        while (p)
            {
                    head->next=p->next;
                    x=p->info;
                    for (j=0;j<i;j++)
                            x=x/10;
                    k=x%10;                                     //取出本次按位分配的值
                    if (q[k].front==NULL)           //队列为空
                    {
                        q[k].front=q[k].rear=p;
                    }
                    else                                            //队列不为空
                    {
                         q[k].rear->next=p;
                         q[k].rear=p;
                    }
                   p=head->next;
            }
        //收集
        r=head;                             //r为链尾指针
        for (j=0;j<10;j++)
        {
            if (q[j].front!=NULL)
                        {   r->next=q[j].front;
                             r=q[j].rear;
                             q[j].front=q[j].rear=NULL;
                        }
        }
        r->next=NULL;
    }
}
int  main()
{
  linklist head;
  printf("数据初始化...\n");
  head=creatLink("data1.txt",N);      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
  printf("数据排序中...\n");
  radixSort(head);
  writetofile(head,"out.txt");              /*排序结果保存在out.txt中*/
  delList(head);
  return 0;
}
数据结构(第4版)习题及实验参考答案-数据结构复习资料完整版(c语言版).docx
12-14
数据结构(第4版)习题及实验参考答案-数据结构复习资料完整版(c语言版).docx
字符数组、排序、查找
vnalk的博客
11-29 579
1.简单排序 设计函数 void bubbleSort(int a[],int n);，实现对整型数组的排序。 输入第一行为一个整数n(0<n<=1000),代表待排序元素的个数。第二行是n个整数，每个整数都不会超过int型的存储范围，为待排序元素。 输出只有一行，为输入的n个待排序元素按从小到大排序后的结果。（建议采用起泡排序算法） 建议设计一个辅助函数: 函数功能：依次输出数组中各个元素，数与数之间用空格分开，最后一个数后没有空格而是换行符 参数说明：数组名，数组内元素个数 void out
数据结构排序算法之插入排序
zjw18737392679的博客
05-19 1312
这篇博客介绍插入排序算法中的三种： 直接插入排序，折半插入排序，希尔排序 一.直接插入排序 1.1 算法思想 直接插入排序是一种最简单的排序算法，其它两种算法都是在直接插入排序算法的基础上的改进。 直接插入排序是将一个记录插入到一个已经排好序的有序表中，初始时，表中只有一个元素，也是有序的。 1.2代码实现 实现一： a[0]不作为哨兵 #include<stdio.h> void I...
数据结构（C语言版)（第3版）实验三（答案）
qq_62804018的博客
03-23 3691
江西师范大学计算机信息工程学院学生实验报告 专业 计算机信息工程学院 姓名 钟宗谨 学号 202126202185日期 2022/3/21 课程名称 数据结构 实验室名称 实验名称 不带头结点的单链表 指导教师 万中英 成绩 实验目的 理解带头结点的单链表的...
插入排序
m0_49371394的博客
01-17 1639
题目描述： 设计函数 void InsertSort(int a[],int n); 该函数使用插入排序算法，将数组a的前n个元素按照升序的方式排序。 插入排序算法描述如下： 初始序列：49 38 65 97 76 13 27 49 将元素(38) 插入合适位置： [38 49] 65 97 76 13 27 49 将元素(65) 插入合适位置： [38 49 65] 97 76 13 27 49 将元素(97) 插入合适位置： [38 49 65 97] 76 13 27 49 将元素(76) 插入合适位
数据结构c语言版_【课后习题答案】数据结构（C语言版）（第2版）—习题答案...
weixin_39945816的博客
12-05 7334
资 源 介 绍本次分享内容为课程课后习题答案【教材名称】：数据结构(C语言版)(第2版)【主编作者】：李云清、杨庆红、揭安全【出版社】：人民邮电出版社【ISBN】：9787115207036【目录】：一、概论二、线性表及其顺序存储三、线性表的链式存储四、字符串、数组和特殊矩阵五、递归六、树型结构七、二叉树八、图九、检索十、内排序课后习题答案温馨提示1、资料下载过程中如有问题请联系小...
数据结构C语言版（李云清）实验5 递归
CSDNadmin00的博客
12-28 4581
实验5 递归 1、 编写递归算法int max(int a[],int left, int right)，求数组a[left…right]中的最大数。 #include "ArrayIo.h" /*请将本函数补充完整，并进行测试*/ int max(int a[],int left,int right) { int lmax,rmax,mid; if (left==right) r...
数据结构C语言版（李云清）实验8 图
CSDNadmin00的博客
12-28 5162
实验8 图 1、编写程序输出以邻接表为存储结构的无向图的各顶点的度。 /**********************************/ /*文件名称：lab8_01.c */ /**********************************/ #include "ljb.h" /* 输出以邻接表为存储结构的无向图g的各顶点的度 */ void deg...
李云清数据结构第三版C语言版课后答案详细解析：深入学习数据结构的利器
gitblog_06761的博客
05-30 415
李云清数据结构第三版C语言版课后答案详细解析：深入学习数据结构的利器 去发现同类优质开源项目:https://gitcode.com/ 项目介绍 在计算机科学领域，数据结构是基础且至关重要的知识点。李云清教授的《数据结构第三版C语言版》以其深入浅出的讲解受到广泛好评。而本开源项目“李云清数据结构第三版C语言版课后答案详细解析”，为读者提供了课后习题的全面解答，助力学习者深入理解数据结构原理，提高编...
排序
weixin_43931042的博客
12-07 630
题目描述 void InsertSort(int a[],int n); 使用插入排序算法，将数组a的前n个元素按照升序的方式排序。 插入排序算法描述如下： 初始序列：49 38 65 97 76 13 27 49 将元素(38) 插入合适位置： [38 49] 65 97 76 13 27 49 将元素(65) 插入合适位置： [38 49 65] 97 76 13 27 49 将元素(97)...
Cadence PSpice仿真总报错？别慌，手把手教你调通时域仿真（附17.4版本参数详解）
最新发布
weixin_33716154的博客
06-03 732
本文详细解析了Cadence PSpice时域仿真中常见的不收敛问题，提供了从基础原理到参数调整的完整解决方案。针对17.4版本，重点介绍了ITL4、步长和精度参数等关键设置，帮助工程师快速解决仿真报错，提高工作效率。
排序——数据结构课程作业
weixin_33845881的博客
12-22 299
(╥╯^╰╥) 1 /* 2 请设计直接插入排序算法函数void insertSort(int a[],int n)，对a[1]..a[n]进行升序排序。 3 并测试在不同数据规模下的排序效率。 4 */ 5 #include "Arrayio.h" 6 #define N 10000 /*N为数据量大小，因data1.txt中只有50万个数，所以自...
排序算法及其部分知识点
weixin_42456671的博客
09-30 849
排序 插入排序（InsertSort） 将一个待排序的记录按其关键字大小插入到前面已排好的子序列中 代码实现 void InsertSort(int A[], int n){ int i, j, temp; for(i=1; i<n; i++){ // 将各元素插入到已排好序的子序列中 if(A[i] < A[i-1]){ // 若A[i]关键字小于其前驱 temp = A[i]; // tem
排序算法1_直接插入排序
mobai
06-06 482
概述：     排序分为两大类，内部排序和外部排序，内部排序指的是待排序记录存放在计算机随机存储器中进行排序过程，外部排序指的是待排序记录数量很大，以致内存不能一次容纳全部记录，在排序过程中尚需对外存进行访问的排序过程，这里我主要给出内部排序：   其中稳定排序：插入排序、冒泡排序、归并排序、基数排序。 直接插入排序：基本操作是将一个记
数据结构C语言版（李云清）实验6 树
CSDNadmin00的博客
12-28 4930
实验6 树 1、编写算法函数void levelorder(tree t)实现树的层次遍历。 #include "tree.h" void levelorder(tree t) /* t为指向树根结点的指针*/ { tree queue[MAXLEN]; /*用队列存放待处理的结点*/ int head=0,end=1; int i; queue[head] = t;...
算法基础-直接插入排序
记录计算机应用的点点滴滴！！！！！
02-27 873
一、直接插入排序 直接插入排序，下面使用了3中方法实现了。 二、算法实现 // 直接插入排序.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include using namespace std; void InsertSort1(int a[],int n); void InsertSort2(int a[],int n); void
排序算法3——直接插入排序
shuzfan的专栏
02-07 1022
直接插入排序的平均复杂度是 \(O(n^2)\)，因此应用场景较少。直接插入排序的思路是： 每次处理一个数据，将其插入到一个已经排好序的子序列中，直到数据处理完毕。下面给出一个动画示例：未完待续。。。。参考资料：（1）WIKI：https://en.wikipedia.org/wiki/Insertion_sort
插入排序C++
指尖飞舞
01-26 529
插入排序InsertionSort，参数是一个数组包含了n个待排序的数，输入的各个数字是原地排序的（sorted in place），意即这些数字就是在数组A中进行重新排序的，在任何时刻，至多只有其中的常数个数字是存储在数组之外的，当过程InsertionSort执行完毕后，输入数组A中就包含了已排好序的数组输出序列。 下面是利用C++语言实现的插入排序代码: #include &lt;io...
经典算法学习——直接插入排序
乞力马扎罗的雪CYF的博客
02-03 2518
直接插入排序也是比较简单的排序，基本思想是：每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子序列中的适当位置，直到全部记录插入完成为止。具体描述如下：设数组为a[0...n-1],（1）初始时，a[0]自成为一个有序区，无序区为a[1...n-1]. 令i=1;（2）将a[i]并入到当前的有序区a[0...i-1]中形成a[0...i]的有序区间；（3）i++并重复（2），直到i==
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值