c语言成绩排序

C++程序

一：有6个学生,每个学生的数据包括学号、姓名、三门课的成绩，设计程序用函数实现。

1 . 计算出每个学生的平均成绩

2 . 将学生数据按平均成绩从高到低排序

程序如下：

#include

#include

const int studentNum=6; //学生数目

const int nameLen=20; //学生姓名长度

const int idLen=15; //学生学号长度

void main()

{

char name[studentNum][nameLen]; //学生姓名

char id[studentNum][idLen]; //学生学号

float score[studentNum][3]; //学生成绩

float sum;

float average[studentNum]; //平均成绩

int i,j; //循环变量

/*******读入学生的姓名、学号、成绩和计算平均成绩**********/

cout <<"Please input"<

cout <<"Format:NAME ID SCORE-THREE A VREAGE-SCORE" <

for(i=0;i

{

cin >>name[i] >>id[i];

sum=0;

for(j=0;j<3;j++)

{

cin >>score[i][j];

sum+=score[i][j];

}

average[i]=sum/3;

cout <

}

/******按照学生成绩排序************/

int max; //排序用，记录当前一趟排序的最大值

for(i=0;i

{

max=i; //先假定第i个元素是最大值

for(j=i+1;j

{

if(average[j]>average[max])

max=j;

}

/***将找到的具有最大值的元素放到当前一趟排序的第一个位置***/

if(i!=max)

{

float tempFloat;

char tempStr[nameLen];

/***交换两个位置的成绩****/

tempFloat=average[i];

average[i]=average[max];

average[max]=tempFloat;

/***交换两个位置的学生姓名***/

strcpy(tempStr,name[i]);

strcpy(name[i],name[max]);

strcpy(name[max],tempStr);

/****交换两个位置的学号***/

strcpy(tempStr,id[i]);

strcpy(id[i],id[max]);

strcpy(id[max],tempStr);

}

}

/*****输出排序后的结果******/

cout <

for(i=0;i

cout <

}

二：有一个字符串，今输入一个字符，编程将字符串中该字符删去，用函数实现。程序如下：

#include

#include

void main()

{

char str[80];

char ch;

int num;

int i,j;

/****字符、字符串的输入*****/

cout <<"Please input a string(shorter 80 chars):" <

cin >>str;

cout <<"Please input a char:" <

cin >>ch;

num=strlen(str); //测量字符串长度

/*****删除字符串中与输入字符相同的字符******/ for(i=0;i

{

if(str[i]==ch)

{

for(j=i;j

str[j]=str[j+1];

str[num-1]=' ';

}

continue;

num--;

}

cout <<"The result is:" <

C语言几种常见的排序方法

C语言几种常见的排序方法 2009-04-2219:55 插入排序是这样实现的： 首先新建一个空列表，用于保存已排序的有序数列（我们称之为"有序列表"）。 从原数列中取出一个数，将其插入"有序列表"中，使其仍旧保持有序状态。 重复2号步骤，直至原数列为空。 插入排序的平均时间复杂度为平方级的，效率不高，但是容易实现。它借助了"逐步扩大成果"的思想，使有序列表的长度逐渐增加，直至其长度等于原列表的长度。 冒泡排序 冒泡排序是这样实现的： 首先将所有待排序的数字放入工作列表中。 从列表的第一个数字到倒数第二个数字，逐个检查：若某一位上的数字大于他的下一位，则将它与它的下一位交换。 重复2号步骤，直至再也不能交换。 冒泡排序的平均时间复杂度与插入排序相同，也是平方级的，但也是非常容易实现的算法。 选择排序 选择排序是这样实现的： 设数组内存放了n个待排数字，数组下标从1开始，到n结束。 i=1 从数组的第i个元素开始到第n个元素，寻找最小的元素。 将上一步找到的最小元素和第i位元素交换。 如果i=n－1算法结束，否则回到第3步 选择排序的平均时间复杂度也是O(n²)的。 快速排序 现在开始，我们要接触高效排序算法了。实践证明，快速排序是所有排序算法中最高效的一种。它采用了分治的思想：先保证列表的前半部分都小于后半部分，然后分别对前半部分和后半部分排序，这样整个列表就有序了。这是一种先进的思想，也是它高效的原因。因为在排序算法中，算法的高效与否与列表中数字间的比较次数有直接的关系，而"保证列表的前半部分都小于后半部分"就使得前半部分的任何一个数从此以后都不再跟后半部分的数进行比较了，大大减少了数字间不必要的比较。但查找数据得另当别论了。 堆排序 堆排序与前面的算法都不同，它是这样的： 首先新建一个空列表，作用与插入排序中的"有序列表"相同。 找到数列中最大的数字，将其加在"有序列表"的末尾，并将其从原数列中删除。 重复2号步骤，直至原数列为空。 堆排序的平均时间复杂度为nlogn,效率高（因为有堆这种数据结构以及它奇妙的特征，使得"找到数列中最大的数字"这样的操作只需要O(1)的时间复杂度，维护需要logn的时间复杂度），但是实现相对复杂（可以说是这里7种算法中比较难实现的）。

C语言9种常用排序法

C语言9种常用排序法 1.冒泡排序 2.选择排序 3.插入排序 4.快速排序 5.希尔排序 6.归并排序 7.堆排序 8.带哨兵的直接插入排序 9.基数排序 例子：乱序输入n个数，输出从小到大排序后的结果1.冒泡排序 #include int main() { int i, j, n, a[100], temp; while(scanf("%d",&n)!=EOF) { for(i=0;i

for(i=0;ia[j+1]) //比较a[j]与a[j+1],使a[j+1]大于a[j] { temp = a[j+1]; a[j+1] = a[j]; a[j] = temp; } } } for(i=0;i int main() {

int i, j, n, a[100], t, temp; while(scanf("%d",&n)!=EOF) { for(i=0;ia[j]) t = j; } temp = a[i]; a[i] = a[t]; a[t] = temp; } for(i=0;i

c语言各种排序方法及其所耗时间比较程序

#i n c l u d e #include #include #include #include const int N=1000;//数据量，用于检测算法质量 const int M=1000;//执行次数 //冒泡排序（递增） void Bubblesort(int r[],int n) { int flag=1;//flag为0停止排序 for(int i=1;i=i;j--) if(r[j]r[i]))i++;

if(ileft) quicksort(r,left,i-1); if(i=0;i--) creatheap(r,i,n); for(i= n-1;i>=0;i--) { t=r[0]; r[0]=r[i]; r[i]=t; creatheap(r,0,i-1); }

c语言实现各种排序程序

C语言实现各种排序方法： 1.快速排序： #include #include void kuai_pai(int *a,int low,int high) { int left,right,middle,i,j,temp; left=low; right=high; middle=(left+right)/2; while(leftlow&&a[right]>a[middle]) right--; if(left<=right) { temp=a[left]; a[left]=a[right]; a[right]=temp; left++;

right--; } } if(leftlow) kuai_pai(a,low,right); } void main() { int *a,i,n; a=(int *)malloc(100); if(NULL==a) { printf("allocation failture\n"); exit(1); } printf("请输入你要排序的元素的个数\n"); scanf("%d",&n); printf("现在开始输入%d个元素\n",n); for(i=0;i!=n;++i) scanf("%d",&a[i]);

kuai_pai(a,0,n-1); printf("排序后为：\n"); for(i=0;i!=n;++i) printf("%d ",a[i]); printf("\n"); free(a); } 2.shell排序 #include #include void shell(int *a,int n) { int gap,i,j,temp; for(gap=n/2;gap>0;gap=gap/2) for(i=gap;i=0&&a[j]>a[j+gap];j=j-gap) { temp=a[j]; a[j]=a[j+gap]; a[j+gap]=temp; } }

c语言各种排序法详细讲解

一插入排序 1.1 直接插入排序 基本思想：每次将一个待排序额记录按其关键码的大小插入到一个已经排好序的有序序列中，直到全部记录排好序。 图解：

1.//直接顺序排序 2.void InsertSort(int r[], int n) 3.{ 4.for (int i=2; i

代码实现： [cpp]view plain copy 1.//希尔排序 2.void ShellSort(int r[], int n) 3.{ 4.int i; 5.int d; 6.int j; 7.for (d=n/2; d>=1; d=d/2) //以增量为d进行直接插入排序 8. { 9.for (i=d+1; i0 && r[0]

C语言排序总汇

C语言排序总汇 1、插入法排序 算法如下： voidInsertsort(int n) { inti,j; for(i=2;i<=n;i++) /*依次插入R[2],R[3],.....R[n]*/ if(R[i]=R[j]时终止*/ R[j+1]=R[0];/*R[i]插入到正确的位置*/ } } 程序代码 #include #define MAX 255/*用户可以自己选*/ int R[MAX];

voidInsertsort(int n) { inti,j; for(i=2;i<=n;i++) /*依次插入R[2],R[3],.....R[n]*/ if(R[i]=R[j]时终止*/ R[j+1]=R[0];/*R[i]插入到正确的位置*/ } } main() { inti,n; puts("Please input total element number of the sequence:"); scanf("%d",&n); if(n<=0||n>MAX)

C语言常用排序算法

/* ===================================================================== ======== 相关知识介绍（所有定义只为帮助读者理解相关概念，并非严格定义）： 1、稳定排序和非稳定排序 简单地说就是所有相等的数经过某种排序方法后，仍能保持它们在排序之前的相对次序，我们就 说这种排序方法是稳定的。反之，就是非稳定的。 比如：一组数排序前是a1,a2,a3,a4,a5，其中a2=a4，经过某种排序后为 a1,a2,a4,a3,a5， 则我们说这种排序是稳定的，因为a2排序前在a4的前面，排序后它还是在a4的前面。假如变成a1,a4, a2,a3,a5就不是稳定的了。 2、内排序和外排序 在排序过程中，所有需要排序的数都在内存，并在内存中调整它们的存储顺序，称为内排序； 在排序过程中，只有部分数被调入内存，并借助内存调整数在外存中的存放顺序排序方法称为外排序。 3、算法的时间复杂度和空间复杂度 所谓算法的时间复杂度，是指执行算法所需要的计算工作量。 一个算法的空间复杂度，一般是指执行这个算法所需要的内存空间。 ===================================================================== =========== */ /* ================================================ 功能：选择排序 输入：数组名称（也就是数组首地址）、数组中元素个数 ================================================ */ /* ==================================================== 算法思想简单描述：

各种排序算法C语言实现

#include #include #define Max 20 //最大顶点数 //顺序存储方式使用的结构体定义 typedef struct vexType { char data; int indegree; }Vex; typedef struct Graph { int vexnum; //顶点数量 int arcnum; //边数 Vex vex_array[Max]; //存放顶点的数组 int arc_array[Max][Max]; //存放邻接矩阵的二维数组}Graph; //图的定义 //链式存储使用的结构体定义 typedef struct arcType { char vex1,vex2; //边所依附的两点 int arcVal; //边的权值 }Arc; //边的定义 typedef struct LinkType { int index; //在顶点表的下标 struct LinkType *nextarc; //指向下一个顶点结点 }LinkNode; //边表定义 typedef struct vexNode { char data; int add; //在顶点数组的下表位置 LinkNode *firstarc; //指向边表的第一个结点

int indegree; //入度 }VexNode; //顶点边定义 typedef struct LGraph { VexNode vex_array[Max]; //顶点数组 int vexnum; //图中顶点数 }LGraph; /*函数功能：图的创建 入口参数：图G 返回值：无 */ void Creat_G(Graph *G) { char v; int i=0; int j=0; G->vexnum=0; printf("输入说明。。。有权值请输入权值，无权值请输入1，无边请输入0\n"); printf("\n请输入所有顶点(不超过20个，按‘#’结束输入)：\n"); do{ printf("输入第%d 个顶点：",G->vexnum+1); scanf(" %c",&v); G->vex_array[G->vexnum].data = v; G->vexnum++; }while(v!='#'); G->vexnum--; printf("输入邻接矩阵（%d * %d）：",G->vexnum,G->vexnum); for(i=0; ivexnum; i++) { printf("输入%c 到以下各点的权值：\n",G->vex_array[i].data); for(j=0; jvexnum; j++) { printf("<%c, %c>: ",G->vex_array[i].data,G->vex_array[j].data); scanf("%d",&G->arc_array[i][j]); }

c语言实现简单排序(8种方法)

#include #include //冒泡排序 voidbubleSort(int data[], int n); //快速排序 voidquickSort(int data[], int low, int high); intfindPos(int data[], int low, int high); //插入排序 voidbInsertSort(int data[], int n); //希尔排序 voidshellSort(int data[], int n); //选择排序 voidselectSort(int data[], int n); //堆排序 voidheapSort(int data[], int n); void swap(int data[], inti, int j); voidheapAdjust(int data[], inti, int n); //归并排序 voidmergeSort(int data[], int first, int last); void merge(int data[], int low, int mid, int high); //基数排序 voidradixSort(int data[], int n); intgetNumPos(intnum, intpos); int main() { int data[10] = {43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; inti; printf("原先数组:"); for(i=0;i<10;i++) { printf("%d ", data[i]); } printf("\n"); /*printf("冒泡排序:"); bubleSort(data, 10); for(i=0;i<10;i++) { printf("%d ", data[i]); } printf("\n"); printf("快速排序:"); quickSort(data, 0, 9); for(i=0;i<10;i++) { printf("%d ", data[i]); } printf("\n");

C语言常用排序算法

1、稳定排序和非稳定排序 简单地说就是所有相等的数经过某种排序方法后，仍能保持它们在排序之前的相对次序，我们就说这种排序方法是稳定的。反之，就是非稳定的。 比如：一组数排序前是a1,a2,a3,a4,a5，其中a2=a4，经过某种排序后为a1,a2,a4,a3,a5，则我们说这种排序是稳定的，因为a2排序前在a4的前面，排序后它还是在a4的前面。假如变成a1,a4,a2,a3,a5就不是稳定的了。 2、内排序和外排序在排序过程中，所有需要排序的数都在内存，并在内存中调整它们的存储顺序，称为内排序； 在排序过程中，只有部分数被调入内存，并借助内存调整数在外存中的存放顺序排序方法称为外排序。 3、算法的时间复杂度和空间复杂度 所谓算法的时间复杂度，是指执行算法所需要的计算工作量。 一个算法的空间复杂度，一般是指执行这个算法所需要的内存空间。 ================================================ 功能：选择排序 输入：数组名称（也就是数组首地址）、数组中元素个数 ==================================================== 算法思想简单描述： 在要排序的一组数中，选出最小的一个数与第一个位置的数交换； 然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环 到倒数第二个数和最后一个数比较为止。 选择排序是不稳定的。算法复杂度O(n2)--[n的平方] ===================================================== void select_sort(int*x,int n) { int i,j,min,t; for(i=0;i

C语言几种排序方法程序

下面是几种排序方法的程序： 1.交换排序 #include #include int main(void) { int a[10] = {1,4,3,0,7,5,2,8,9,6}; int i = 0, j = 0; int temp = 0; for(i = 0; i< 9; i++) { for(j = i+1; j<10; j++) { if(a[i]>a[j]) { temp = a[i]; a[i] = a[j]; a[j] = temp; } } } for(i = 0; i<10; i++) { printf("%d\t", a[i]); if((i+1)%5 == 0) printf("\n"); } // printf("\n"); return 0; } 2.插入排序 #include #include int main(void) { int a[9] = {5,8,3,9,2,0,4,7,10}; int temp = 0, i = 0, j = 0, z=0; for(i=0; i<9; i++)

{ for(j=i+1; j<9; j++) { if(a[j] < a[i]) { temp = a[j]; for(z = j-1; z >= i; z--) { a[z+1] = a[z]; } a[i] = temp; } } } for(i = 0; i<9; i++) { printf("%d\t", a[i]); if((i+1)%5 == 0) printf("\n"); } printf("\n"); return 0; } 3.归并 #include #include int merge(int *a, int begin, int end) { int *c = NULL; int i = 0; int x = 0, y = 0; int mid = 0; mid = (begin+end)/2; x = begin; y = mid+1; c = (int *)malloc((end+1)*4); if(c == NULL) return 0; for(i = begin; i<(end+1); i++) {

c语言各种排序方法及其所耗时间比较程序

#include <> #include <> #include <> #include <> const int N=1000;// const int M=1000;// // 冒泡排序（递增） void Bubblesort(int r[],int n) { int flag=1;//flag 为0 停止排序 for(int i=1;i=i;j--) if(r[j] 数据量，用于检测算法质 量 执行次数 }

while((ir[i]))i++; if(ileft) quicksort(r,left,i-1); if(i=0;i--) creatheap(r,i,n); for(i= n-1;i>=0;i--) { t=r[0]; r[0]=r[i]; r[i]=t; creatheap(r,0,i-1);

c语言各种排序方法及其所耗时间比较程序

#i n c l u d e<> #include <> #include <> #include <> #include <> const int N=1000;//数据量，用于检测算法质量 const int M=1000;//执行次数 //冒泡排序（递增） void Bubblesort(int r[],int n) { int flag=1;//flag为0停止排序 for(int i=1;i=i;j--) if(r[j]

while((ir[i]))i++; if(ileft) quicksort(r,left,i-1); if(i=0;i--) creatheap(r,i,n); for(i= n-1;i>=0;i--) { t=r[0]; r[0]=r[i]; r[i]=t; creatheap(r,0,i-1);

c语言程序设计(排序算法)

《高级语言程序设计》 课程设计报告 题目： 排序算法 专业： 班级： 姓名： 指导教师： 成绩： 计算机与信息工程系 2015年3月26日 2014-2015学年 第2学期

目录 引言 (1) 需求分析 (1) 第一章程序内容及要求 (1) 1.1 冒泡排序 (1) 1.2 选择排序 (2) 1.3 插入排序 (3) 第二章概要设计 (4) 2.1冒泡排序 (4) 2.2选择排序 (5) 2.3插入排序 (6) 第三章程序的比较及其应用 (7) 3.1时间复杂度 (7) 3.2空间复杂度 (7) 3.3稳定程度 (7) 3.4应用及其改进 (8) 第四章程序设计结果 (9) 附录 (9) 参考文献 (13)

引言 伴随着社会的发展，数据也变得越来越庞大。如何将庞大的数据进行很好的排序，使用户更加方便的查找资料，成了一件越来越重要的问题。对于程序员来说，这将是一个挑战。 经常查找资料的朋友都会知道，面对海量的资料，如果其查找资料没有进行排序，那么其查找资料将会是一家非常痛苦的事情。针对这一问题，我们自此通过一个课程设计来解决它。 理论上排序算法有很多种，不过本课程设计只涉及到三种算法。这三种算法包括：冒泡排序，选择排序，直接插入排序。 本课程设计通过对这三种算法的运行情况进行对比，选择最优秀的算法出来。希望通过我的努力能解决一些问题，带来一些方便。 需求分析 本课程题目是排序算法的实现，由于各方面的原因，本科程设计一共需要设计三种排序算法。这三种算法包括：冒泡排序，选择排序，直接插入排序。三种排序算法各有独到之处，因此我们要通过各种调试分析来比较其优劣长短。 由于使用的调试软件及操作系统不一样。因此个别程序在不同的软件上可能会报错。 本课程软件运行的的操作系统为Windows7 64位操作系统。所使用的软件为Microsoft Visual C++6.0以及Turbo C2.0 第一章程序内容及要求 1.1 冒泡排序 冒泡排序（Bubble Sort，台湾译为：泡沫排序或气泡排序）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名。

c语言经典排序算法(8种-含源代码)

天行健，君子以自强不息 常见经典排序算法 1.希尔排序 2.二分插入法 3.直接插入法 4.带哨兵的直接排序法 5.冒泡排序 6.选择排序 7.快速排序 8.堆排序 一.希尔（Shell）排序法（又称宿小增量排序，是1959年由D.L.Shell提出来的） /* Shell 排序法 */ #include void sort(int v[],int n) { int gap,i,j,temp; for(gap=n/2;gap>0;gap /= 2) /* 设置排序的步长，步长gap每次减半，直到减到1 */ { for(i=gap;i= 0) && (v[j] > v[j+gap]);j -= gap ) /* 比较相距gap远的两个元素的大小，根据排序方向决定如何调换 */ { temp=v[j]; v[j]=v[j+gap]; v[j+gap]=temp; } } } } 二.二分插入法

/* 二分插入法 */ void HalfInsertSort(int a[], int len) { int i, j,temp; int low, high, mid; for (i=1; i temp) /* 如果中间元素比但前元素大，当前元素要插入到中间元素的左侧 */ { high = mid-1; } else /* 如果中间元素比当前元素小，但前元素要插入到中间元素的右侧 */ { low = mid+1; } } /* 找到当前元素的位置，在low和high之间 */ for (j=i-1; j>high; j--)/* 元素后移 */ { a[j+1] = a[j]; } a[high+1] = temp; /* 插入 */ } } 三.直接插入法 /*直接插入法*/ void InsertionSort(int input[],int len) { int i,j,temp; for (i = 1; i < len; i++) { temp = input[i]; /* 操作当前元素，先保存在其它变量中 */

c语言各种排序方法与所耗时间比较程

#include #include #include #include #include const int N=1000。//数据量，用于检测算法质量const int M=1000。//执行次数 //冒泡排序（递增） void Bubblesort(int r[],int n) { int flag=1。//flag为0停止排序 for(int i=1。i=i。j--) if(r[j]

void quicksort(int r[],int left,int right) { int i,j。 int swap。 i=left。j=right。 swap=r[left]。 while(ir[i]))i++。 if(ileft) quicksort(r,left,i-1)。 if(i

C语言顺序结构

第四章C语言顺序结构 4.1 C语句概述 一般来说，程序设计语言中的流程控制结构分为3种：顺序结构、选择结构和循环结构。 C程序语句 表达式语句 函数调用语句 控制语句 复合语句 空语句 条件判断语句：if语句，switch语句。 循环执行语句：do while语句，while语句，for语句 转向语句：break语句，goto语句，continue语句，return语句 表达式语句由表达式加上分号“；”组成，其一般形式为：表达式； 函数调用语句由函数名、实际参数加上分号“；”组成。其一般形式： 函数名（实际参数表） 控制语句用于控制程序的流程，以实现程序的各种结构方式。C语言中共有9种控制语句，可以将其分为如下3类： 复合语句：把多个语句用{}括起来组成的一个语句称为复合语句。在程序中应把复合语句看成是单条语句，而不是多条语句。 空语句：只有分号“；”组成的语句。 4.2赋值语句 赋值语句是表达式语句的一种，是由赋值表达式再加上分号构成的表达式语句，其一般形式为：变量=表达式； 注意在变量声明中给变量赋初值和赋值语句的区别。给变量赋初值是变量声明的一部分，赋初值后的变量与其后的其它同类变量之间仍必须用逗号间隔，而赋值语句则必须用分号结尾。例如int a=1，b；是在变量声明中对变量a赋初值，其等效于如下两条语句; int a,b; /*定义整型变量a,b*/ a=1; /*为变量a赋值*/ 在变量声明中，不允许给多个连续变量赋初值。下列说明是错误的：int a=b=c=1；，必须写为inta=1,b=1,c=1; 4.3格式输入输出 格式输入输出即向标准输出设备显示器输出数据的语句。 4.3.1printf函数——格式输出 printf函数称为格式输出函数，其关键字最末一个字母“f”即为格式（format）之意。printf函数的功能是按用户指定的格式，把指定的数据显示到显示器屏幕上。printf函数是一个标准库函数，它的函数原型在头文件“stdio.h”中。但作为一个特例，不要求在使用printf函数之前必须包含stdio.h文件。 printf函数调用的一般形式为： printf（“格式控制字符串”，输出列表） 其中，格式字符串用于指定输出格式，可由格式字符串和非格式字符串两种组成。格式字符串是以%开头的字符串，在%后面跟有各种格式字符，以说明输出数据的类型、形式、长度、小数位等。例如：“%d”表示按十进制整型输出，“%f”表示按十进制浮点型输出，“%c”表示按字符型输出。 表4-1

基于C语言的多种排序方法的实现

基于C语言的多种排序方法的实现 1 引言 1.1 课题背景 排序问题源远流长，一直是数学地重要组成部分。随着各种信息的快速更新，排序问题也走进了其他领域以及我们地日常生活。如何高效地排序一直困扰着我们。 1.2 课程设计目的 排序是数学的重要组成部分，工作量大是其存在的问题。如何高效地排序？本程序就是解决这个问题而设计。程序中，把数列储存在数组中，采用插入排序等十种排序方法对数组元素进行排序，高效地解决了排序问题。本软件开发的平台为最新的微软公司出版的市面最新系统Windows 2000，而且可以作为自身的运行平台非常广泛，包括Windows 98/2000/XP/Vista等等。 1.3课程设计内容 本程序把对数列的排序转化为对数组元素的排序，用户可以根据自己的实际问题选择系统提供的七种排序方法的任意一种进行排序。程序通过自身的判断以及处理实现排序。程序最后输出每趟排序及初始排序结果。 2 系统分析与设计方案

2.1系统分析 设计一个排序信息管理系统，使之能够操作实现以下功能： 1) 显示需要输入的排序长度及其各个关键字 2) 初始化输入的排序序列 3) 显示可供选择的操作菜单 4) 显示输出操作后的移动次数和比较次数 5) 显示操作后的新序列 5) 可实现循环继续操 2.2设计思路 通过定义C语言顺序表来存储排序元素信息，构造相关函数，对输入的元素进行相应的处理。[2] 2.3设计方案 设计方案如图2.1所示 图2.1 设计方案 具体流程见图2.2

图2.2 程序流程图

3功能设计 3.1 SqList顺序表 其中包括顺序表长度，以及顺序表。源代码如下：[1] typedef struct { KeyType key; //关键字项 InfoType otherinfo; //其他数据项 }RedType; typedef struct { RedType r[MaxSize+1]; //r[0]作为监视哨 int length; //顺序表长度 }SqList; 3.2 直接插入排序 直接插入排序是将一个记录插入到已排好序的有序表中，从而得到一个新的、记录数增1的有序表 图3.1 直接插入排序示意图

C语言学生成绩排序

课程设计报告 学生姓名：郑泷浩朱恒栋霍永杰周龙专业：电子信息科学与技术 班级：2010电子 2013年01月07 日

目录 课程设计目的与要求 (3) 程序设计题目 (4) 调试与测试 (5) 实验思路 (6) 源程序清单 (7) 执行结果........................................ .11 实验小结. (12)

课程设计目的与要求 一. 课程设计目的： 本次课程设计的主要目的是综合运用所学的C语言知识解决一个比较实际的简单问题，侧重对数组、函数、指针、结构体和文件等相关内容的综合应用，使同学们能进一步熟悉掌握C语言的基本语法，进一步提升自己的编程能力并逐步培养编程思维，进而不断提高同学们解决问题的能力，并为以后的语言学习打下良好的基础。 二. 课程设计要求： 1. 学生独立完成课程设计的主要内容； 2. 按照实验课表安排进行，不得无故旷课； 3．按照选题规则确定课程设计题目，不可随意更换，但可在完成规定的任务之后，根据个人兴趣选做其它题目； 4．严格按照报告格式撰写课程设计报告； 5．程序实现方式可以自选，可采用指针、数组或其任意组合方式完成。

程序设计题目 1．学生成绩排序 （1）定义一个数组a[11],用以存放学生的成绩，从键盘输入10个学生成 绩； （2）采用冒泡法，将学生成绩按照从高到低进行排序并输出 （3）再输入一个学生的成绩，将此成绩按照排序规律插入原学生成绩数组， 输出结果； （4）将排好序的成绩单进行反序存放并输出，即原来是从高到低，现改为 从低到高排列；

调试与测试 在设计时，没打出一个模块都进行调试与测试，如果错误或不能达到预期效果，就检查。调试过程中总是会出现数组名和变量名不一样的问题。检查时，通过查资料、问同学老师解决。