C语言程序—直接选择排序

#include

#define MAX 50

typedef struct

{ int key;

char data;

} datatype;

int getsort(datatype x[] );

void selectsort(datatype x[],int n);

void print(datatype x[],int n);

void main()

{ datatype x[MAX];

int n,sel; /*sel 输入选择，n 排序记录的长度*/

printf("请输入你的选择：1---开始其它选择为退出\nyour choice =");

scanf("%d",&sel);

while(sel==1)

{ printf("\n请输入关键字序列，以-1结束输入：\n");

n=getsort(x);

printf("\n排序前的结果为：\n");

print(x,n);

printf("\n");

printf("排序的过程为：\n");

selectsort(x,n);

printf("\n直接选择排序后的结果为：\n");

print(x,n);

printf("\n");

printf("请输入你的选择：1---开始其它选择为退出\nyour choice =");

scanf("%d",&sel); } }

/*输入记录的关键字*/

int getsort(datatype x[] )

{ int i=0;

scanf("%d",&x[i].key);

while(x[i].key!=-1)

{ i++;

scanf("%d",&x[i].key); }

return i; }

/*直接排序*/

void selectsort(datatype x[],int n)

{ int i,j,small;

datatype temp;

for (i=0;i

{ small=i;

for (j=i+1;j

if (x[j].key

small=j;

if (small!=i) /*当关键字最小记录的下标不为i时，交换记录位置*/

{ temp=x[i];

x[i]=x[small];

x[small]=temp; }

print(x,n);

printf("\n"); } }

void print(datatype x[],int n)

{

int i;

for(i=0;i

printf("%d\t",x[i].key);

}

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语言各种排序法详细讲解

一插入排序 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语言的四种排序

简单选择排序 /*对整型数组的元素进行简单选择排序(源程序的整型简单选择排序)*/ #include #include #define N 6 void taxis(int b[],int k) { int i,j,temp; for(i=0;ib[j]) { temp=b[i]; b[i]=b[j]; b[j]=temp; } } void main() { int a[N]={9,8,5,6,2,0},i; clrscr(); taxis(a,N); for(i=0;i #include #define N 6 void taxis(int *p1,int k) { int temp,*p2,*p3; for(p2=p1;p2*p3) { temp=*p2; *p2=*p3; *p3=temp; } } void main() { int a[N]={9,8,5,6,2,0},*p; clrscr(); taxis(a,N); for(p=a;p

printf("%d",*p); if(p #include #include #define N 5 void taxis(char *p1[],int k) { int i,j; char *temp; for(i=0;istrlen(p1[j])) { temp=p1[i]; p1[i]=p1[j]; p1[j]=temp; } } void main() { char *a[]={"Follow","BASIC","Great","FORTRAN","Computer"}; int i; clrscr(); taxis(a,N); printf("The result of taxis is:\n"); for(i=0;i #include #include #define N 5 void taxis(char *p1[],int k) { int i,j; char *temp; for(i=0;i0) { temp=p1[i]; p1[i]=p1[j]; p1[j]=temp; } }

基于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 直接插入排序示意图 将第i个记录地关键字r[i].key顺序地与前面记录地关键字r[i-1].key,r[i-2].key,……，r[1].key进行比较，把所有关键字大于r[i].key地记录依次后移一位，直到关键字小于或者等于r[i].key地记录

c语言的三种排序(冒泡,快速,选择)

关于本周学习汇总 1起泡排序： 过程：首先将第一个记录的关键字和第二字的关键字进行比较，若为逆序，则将两个记录交换。然后再比较第二个记录跟第三个记录关键字。以此类推，直到第n-1个记录和第n个记录关键字进行比较为止。这样做出了第一趟排序。其结果是使得最大的数在第n的记录。然后对前n-1的记录进行同样的操作。结果得出次大的大在n-1记录上。最后直到只有第1个和第2个记录进行比较后，完成所有的排序。由此可以看出需要进行k（1<=k void swap(int *,int *); void bubble(int a[];int n); int main(viod) { Int n ,a[8]; Int i; Printf(“enter n(n<=8):”); scanf(“%d”,&n); printf(“enter a[%d]”,n); for(i=0;ia[j+1]) swap2(&a[j],&a[j+1]); } void swap2(int *px,int *py) { Int t; t=*px; px=*py; py=t;

常见经典排序算法(C语言)1希尔排序 二分插入法 直接插入法 带哨兵的直接排序法 冒泡排序 选择排序 快速排

常见经典排序算法（C语言） 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; /* 插入*/ } }

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语言 选择排序

(一)基本思想 每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。 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趟直接选择排序得到有序结果。 [编辑本段]排序过程 【示例】： 初始关键字[49 38 65 97 76 13 27 49] 第一趟排序后13 ［38 65 97 76 49 27 49] 第二趟排序后13 27 ［65 97 76 49 38 49] 第三趟排序后13 27 38 [97 76 49 65 49] 第四趟排序后13 27 38 49 [49 97 65 76] 第五趟排序后13 27 38 49 49 [97 65 76] 第六趟排序后13 27 38 49 49 65 [97 76] 第七趟排序后13 27 38 49 49 76 [97 76] 最后排序结果13 27 38 49 49 76 76 97 (二)C语言过程 void selectionSort(Type* arr,long len) { long i=0,j=0;/*iterator value*/ long maxPos; assertF(arr!=NULL,"In InsertSort sort,arr is NULL\n"); for(i=len-1;i>=1;i--) { maxPos=i; for(j=0;j

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

c语言各种排序方法及其所耗时间比较程序 The latest revision on November 22, 2020

#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) 第四章程序设计结果 (8) 附录 (9) 参考文献 (12)

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

C语言综合实现所有排序方法及效率比较

#include #include #include #include #define N 50000 typedef char elemtype; typedef struct { int key; elemtype otheritem; }recdtype,*Recdtype; recdtype R[N]; //直接插入排序 void InsertSort(Recdtype R,int n) { int i,j; for(i=2;i<=n;i++) { R[0]=R[i]; j=i-1; while(R[0].key=high+1;j--) R[j+1]=R[j]; R[high+1]=R[0];

} }/*BinSort*/ //希尔排序 void ShellSort(recdtype R[],int n) { int i,j; for(int d=N/2;d>=1;d=d/2) { for(i=1+d;i<=n;i++) { R[0]=R[i]; j=i-d; while(j>0&&R[0].key=i;j--) { if(R[j+1].key

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语言之选择排序

选择法排序是相对好理解的排序算法。假设要对含有n个数的序列进行升序排列，算法步骤是： 1、从数组存放的n个数中找出最小数的下标（算法见下面的“求最值”），然后将最小数与第1个数交换位置； 2、除第1个数以外，再从其余n-1个数中找出最小数（即n个数中的次小数）的下标，将此数与第2个数交换位置； 3、重复步骤1 n-1趟，即可完成所求。 好了，接下来看代码:

1.#include 2.#include 3.#define n 10 4.int main() 5.{ 6.int a[n],i,j,k,t; 7. printf("随机产生10个100以内的数:\n"); 8.for(i=0;i

排序算法C语言版：直接插入排序

直接插入排序 算法思想简单描述： 在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排 好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。 直接插入排序是稳定的。算法时间复杂度O(n^2) 算法实现： /* 功能：直接插入排序 输入：数组名称（也就是数组首地址）、数组中元素个数 */ void insert_sort(int *x, int n) { int i, j, t; for (i=1; i

*/ t=*(x+ I ); for (j=i-1; j>=0 && t<*(x+j); j--) /*注意：j=i-1，j--，这里就是下标为i的数，在它前面有序列中找插入位置。*/ { *(x+j+1) = *(x+ j ); /*如果满足条件就往后挪。最坏的情况就是t比下标为0的数都小，它要放在最前面，j==-1，退出循环*/ } *(x+j+1) = t; /*找到下标为i的数的放置位置*/ } }

#include "stdio.h" #include "conio.h" main() { int a[11]={1,4,6,9,13,16,19,28,40,100}; int temp1,temp2,number,end,i,j; printf("original array is:\n"); for(i=0;i<10;i++) printf("%5d",a[i]); printf("\n"); printf("insert a new number:"); scanf("%d",&number); end=a[9]; if(number>end) a[10]=number; else { for(i=0;i<10;i++) { if(a[i]>number) { temp1=a[i]; a[i]=number; for(j=i+1;j<11;j++) { temp2=a[j]; a[j]=temp1; temp1=temp2; } break; } } } for(i=0;i<11;i++) printf("%6d",a[i]); getch();

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

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

《基于C 语言的多种排序方法的实现》第 1 页共30页基于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

C语言三种基本排序(简单排序,选择排序,插入排序)演示程序(含注释、每一个步骤,原创) -修订

/******************************************************* 三种基本排序演示程序 说明：此程序适用于理解三种基本排序原理（简单排序，选择排序，插入排序）以及排序的每一个步骤。并且在重要部分有注释. 本人是一家计算机培训机构的兼职教师（培训计算机C二级的），看到许多同学对于排序非常头疼，当然这是二级C的必考点之一，也是贯穿C语言各种知识点的拿分大项。 本程序是自己按照原理写的原创代码，所以定为1分吧（辛苦费吧，一般我搜集的都是免费的(*^__^*) ……，望大家支持下） 此程序我调试运行成功的，如果你复制到编译器不成功，可能是编译器区别造成的。 如果能自己写出这三种排序的同学，我觉得其对C语言基础知识学习就比较牢固了。 时间：2012年12月3日 ********************************************************/ #include #include void main() { int a[5]={5,4,3,2,1}; int i,j,temp,k,s; for(s=0;s<5;s++) { printf("%3d",a[s]); } printf("简单排序\n"); for(i=0;i<5-1;i++)//基准位到倒数第二个就行了，因为最后一个数没有比较 { printf("%d\n",i);/////////////////////////////// for(j=i+1;j<5;j++) { if(a[j]

数据结构(C语言版)实验报告-(内部排序算法比较)

数据结构与算法》实验报告 一、需求分析 问题描述：在教科书中，各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶，或大概执行时间。试通过随机数据比较各算法的关键字比较次数和关键字移动次数，以取得直观感受。 基本要求： （l ）对以下 6 种常用的内部排序算法进行比较：起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序。 （2 ）待排序表的表长不小于100000 ；其中的数据要用伪随机数程序产生；至少要用 5 组不同的输入数据作比较；比较的指标为有关键字参加的比较次数和关键字的移动次数（关键字交换计为 3 次移动）。 （ 3 ）最后要对结果作简单分析，包括对各组数据得出结果波动大小的解释。数据测试：二．概要设计 1. 程序所需的抽象数据类型的定义： typedef int BOOL; typedef struct StudentData { } Data; typedef struct LinkList { Data Record[MAXSIZE]; int num; // 存放关键字 int Length; // 数组长度// 用数组存放所有的随机数 // 说明BOOL 是int 的别名 } LinkList int RandArray[MAXSIZE]; // 定义长度为MAXSIZE 的随机数组 void RandomNum() // 随机生成函数

void InitLinkList(LinkList* L) // 初始化链表 // 比较所有排序 2 . 各程序模块之间的层次（调用）关系： BOOL LT(int i, int j,int* CmpNum) // 比较 i 和 j 的大小 void Display(LinkList* L) // 显示输出函数 void ShellSort(LinkList* L, int dlta[], int t,int* CmpNum, int* ChgNum) void QuickSort (LinkList* L, // 快速排序 void HeapSort (LinkList* L, // 堆排序 void BubbleSort(LinkList* L, // 冒泡排序 void SelSort(LinkList* L, // 选择排序 int* CmpNum, int* ChgNum) int* CmpNum, int* ChgNum) int* CmpNum, int* ChgNum) * CmpNum, int* ChgNum) void Compare(LinkList* L,int* CmpNum, int* ChgNum) // 希尔排序

c语言版5种排序方法

冒泡排序: #include void Bubblesort(int *a,int n); void main() { int i; int a[]={8,7,6,5,4,3,2}; Bubblesort(a,7); for (i=0;i<7;i++) printf("%d\n",a[i]); } void Bubblesort(int *a,int n) { int i,j,temp; for(i=0;ia[j+1]) //进行两两比较，进行交换，沉下重的数 { temp=a[j+1]; a[j+1]=a[j]; a[j]=temp; } } } 插入排序： #include void insertsort(int *a,int n); void main() { int i; int a[]={8,7,6,5,4,3,2}; insertsort(a,7);

for (i=0;i<7;i++) printf("%d\n",a[i]); } void insertsort(int *a,int n) { int i,j,temp; for(i=1;i=0&&temp #include void Merge(int sourceArr[],int tempArr[], int startIndex, int midIndex, int endIndex); void MergeSort(int sourceArr[], int tempArr[], int startIndex, int endIndex); void main() { int i, b[7]; int a[]={8,7,6,5,4,3,2}; MergeSort(a, b, 0, 6); for (i=0;i<7;i++) printf("%d\n",a[i]); }