实验 各种排序方法的比较

合集下载

内部排序比较 (实验报告+源程序)C++

内部排序比较  (实验报告+源程序)C++

实验报告3实验名称:数据结构与软件设计实习题目:内部排序算法比较专业:生物信息学班级:01 姓名:学号:实验日期:2010.07.24一、实验目的:比较冒泡排序、直接插入排序、简单选择排序、快速排序、希尔排序;二、实验要求:待排序长度不小于100,数据可有随机函数产生,用五组不同输入数据做比较,比较的指标为关键字参加比较的次数和关键字移动的次数;对结果做简单的分析,包括各组数据得出结果的解释;设计程序用顺序存储。

三、实验内容对各种内部排序算法的时间复杂度有一个比较直观的感受,包括关键字比较次数和关键字移动次数。

将排序算法进行合编在一起,可考虑用顺序执行各种排序算法来执行,最后输出所有结果。

四、实验编程结果或过程:1. 数据定义typedef struct { KeyType key; }RedType; typedef struct { RedType r[MAXSIZE+1]; int length;}SqList;2. 函数如下,代码详见文件“排序比较.cpp”int Create_Sq(SqList &L)void Bubble_sort(SqList &L)//冒泡排序void InsertSort(SqList &L)//插入排序void SelectSort(SqList &L) //简单选择排序int Partition(SqList &L,int low,int high) void QSort(SqList &L,int low,int high)//递归形式的快速排序算法void QuickSort(SqList &L)void ShellInsert(SqList &L,int dk)//希尔排序void ShellSort(SqList &L,int dlta[ ])3. 运行测试结果,运行结果无误,如下图语速个数为20元素个数为100错误调试无。

排序实验报告_排序综合实验报告材料

排序实验报告_排序综合实验报告材料

班级
2*10^7
10 电信 1 班
10^8
操作系统
10^5
Microsoft Windows 7 旗舰版 (64 位/Service Pck 1)
正序
xxxxxxxxxxxxx
逆序
编译软件
直接插入
Visul C++ 6.0
(带监视哨〕
emil
C
609803959.
24.874
10^4
100.158
2*10^4
中选出键值最小的记录,与无序区第一个记录 R 交换;新的无序区为 R 到
各种排序试验结果:
R[n],从中再选出键值最小的记录,与无序区第一个记录 R 交换;类似, CPU
第 i 趟排序时 R 到 R[i-1]是有序区,无序区为 R[i]到 R[n],从中选出键
(英特尔)Intel(R) Core(TM) i5 CPU M 480 2.67GHz
〔1〕二路并归排序:开始时,将排序表 R 到 R[n]看成 n 个长度为 1
录,顺序放在已排好序的子序列的后面〔或最前〕,直到全部记录排序完 的有序子表,把这些子表两两并归,便得到 n/2 个有序的子表〔当 n 为奇
毕。
数时,并归后仍是有一个长度为 1 的子表〕;然后,再把这 n/2 个有序的
〔1〕直接选择排序:首先,全部记录组成初始无序区 R 到 R[n],从 子表两两并归,如此反复,直到最终得到一个程度为 n 的有序表为止。
指导老师: 胡圣荣
序与排序要求相反时就交换两者的位置,直到没有反序的记录为止。
日期: 20XX.12.15~20XX.1.5
〔1〕冒泡排序:设想排序表 R 到 R[n]垂直放置,将每个记录 R[i]看

算法课设实验报告(3篇)

算法课设实验报告(3篇)

第1篇一、实验背景与目的随着计算机技术的飞速发展,算法在计算机科学中扮演着至关重要的角色。

为了加深对算法设计与分析的理解,提高实际应用能力,本实验课程设计旨在通过实际操作,让学生掌握算法设计与分析的基本方法,学会运用所学知识解决实际问题。

二、实验内容与步骤本次实验共分为三个部分,分别为排序算法、贪心算法和动态规划算法的设计与实现。

1. 排序算法(1)实验目的:熟悉常见的排序算法,理解其原理,比较其优缺点,并实现至少三种排序算法。

(2)实验内容:- 实现冒泡排序、快速排序和归并排序三种算法。

- 对每种算法进行时间复杂度和空间复杂度的分析。

- 编写测试程序,对算法进行性能测试,比较不同算法的优劣。

(3)实验步骤:- 分析冒泡排序、快速排序和归并排序的原理。

- 编写三种排序算法的代码。

- 分析代码的时间复杂度和空间复杂度。

- 编写测试程序,生成随机测试数据,测试三种算法的性能。

- 比较三种算法的运行时间和内存占用。

2. 贪心算法(1)实验目的:理解贪心算法的基本思想,掌握贪心算法的解题步骤,并实现一个贪心算法问题。

(2)实验内容:- 实现一个贪心算法问题,如活动选择问题。

- 分析贪心算法的正确性,并证明其最优性。

(3)实验步骤:- 分析活动选择问题的贪心策略。

- 编写贪心算法的代码。

- 分析贪心算法的正确性,并证明其最优性。

- 编写测试程序,验证贪心算法的正确性。

3. 动态规划算法(1)实验目的:理解动态规划算法的基本思想,掌握动态规划算法的解题步骤,并实现一个动态规划算法问题。

(2)实验内容:- 实现一个动态规划算法问题,如背包问题。

- 分析动态规划算法的正确性,并证明其最优性。

(3)实验步骤:- 分析背包问题的动态规划策略。

- 编写动态规划算法的代码。

- 分析动态规划算法的正确性,并证明其最优性。

- 编写测试程序,验证动态规划算法的正确性。

三、实验结果与分析1. 排序算法实验结果:- 冒泡排序:时间复杂度O(n^2),空间复杂度O(1)。

对偶比较法_等级排列法和两极递进式排序法的比较

对偶比较法_等级排列法和两极递进式排序法的比较

对偶比较法、等级排列法和两极递进式排序法的比较Ξ田晓明 冯成志ΞΞ(教育部人文社科重点研究基地苏州大学中国特色城镇化道路研究中心,苏州大学心理学系,苏州,215006)摘 要 排序不仅是科学研究的常用方法,在现实生活中也有着广泛应用,但对于不同排序方法排序结果的比较却鲜有报道。

本研究通过颜色偏好实验考察了对偶比较法、等级排列法和两极递进式排序法三种排序方法的稳定性和一致性等指标,并比较了三种方法的优劣。

结果表明:三种排序方法在颜色偏好的判断作业中具有较高的稳定性和一致性,其中以对偶比较法的稳定性稍高;三种排序方法在稳定性、经济性、简便性、直观性和适用条件上各有优劣,文末就三种排序方法的应用提出了建议。

关键词 对偶比较法,等级排列法,两极递进式排序法,颜色偏好1 引言 在心理物理学的研究中,建立顺序量表的常用方法有:等级排列法和对偶比较法。

等级排列法是把许多刺激同时呈现,让被试以一定标准将刺激排序,尽管其具有较高的内部一致性[1];但被试在等级排列时会随着被比较刺激数目的增加变得难以抉择,有研究者建议采用等级排列法时刺激的数目以不超过25为宜[2]。

对偶比较法首先将所有要比较的刺激配成对,然后逐对呈现,让被试就刺激的某一特性进行比较,判断两个刺激中的哪一个在这个特性上更明显。

其优点是可以检测被试在比较的过程中是否存在非传递性,即比较过程中出现三角循环现象;但在实际应用中,由于两两比较的次数随N 的增大而快速增加,一般说来被比较对象不超过15个[3]。

另外一种较少提及的方法是两极递进式排序法,是从同时呈现的许多刺激中根据一定标准先筛选出最优的n (n ≥1)个刺激,再筛选出n (n ≥1)个最劣的刺激;然后对剩余的刺激进行层层递进式两极评判,直至筛选完毕。

该方法在绩效评估中应用较多,由于从一批员工中区分出最好的和最差的相对比较容易,两极递进式排序法更受人们的欢迎。

这些方法不仅在心理学的研究中有着广泛的应用,例如对社会价值的判断、心理健康评估、感知觉的测量、跨文化比较及偏好判断等[4-9];而且在教育学、生物测量学、经济学、市场与广告学、医学、计算机工程和管理学中也发挥着重要作用[1,10-16]。

实验报告_冒泡排序法(3篇)

实验报告_冒泡排序法(3篇)

第1篇一、实验目的1. 理解冒泡排序算法的基本原理和操作步骤。

2. 掌握冒泡排序算法的实现方法。

3. 分析冒泡排序算法的时间复杂度和空间复杂度。

4. 通过实验验证冒泡排序算法的效率。

二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019三、实验原理冒泡排序是一种简单的排序算法,其基本思想是通过多次比较和交换相邻元素,将待排序的序列变为有序序列。

冒泡排序算法的基本步骤如下:1. 从第一个元素开始,相邻的两个元素进行比较,如果它们的顺序错误(即第一个元素大于第二个元素),则交换它们的位置。

2. 重复步骤1,对相邻的元素进行比较和交换,直到整个序列的最后一个元素。

3. 第一轮排序完成后,最大的元素被放置在序列的最后一个位置。

4. 从第一个元素开始,对剩余的元素重复步骤1和步骤2,直到序列的倒数第二个元素。

5. 重复步骤3和步骤4,直到整个序列有序。

四、实验步骤1. 编写冒泡排序算法的C++代码,实现上述算法步骤。

2. 在主函数中创建一个待排序的数组。

3. 调用冒泡排序函数对数组进行排序。

4. 输出排序前后的数组,验证排序结果。

五、实验代码```cppinclude <iostream>using namespace std;// 冒泡排序函数void bubbleSort(int arr[], int n) {for (int i = 0; i < n - 1; i++) {for (int j = 0; j < n - i - 1; j++) { if (arr[j] > arr[j + 1]) {// 交换相邻元素int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}// 打印数组函数void printArray(int arr[], int n) {for (int i = 0; i < n; i++) {cout << arr[i] << " ";}cout << endl;}int main() {// 创建待排序的数组int arr[] = {64, 34, 25, 12, 22, 11, 90};int n = sizeof(arr) / sizeof(arr[0]);// 打印排序前的数组cout << "排序前的数组:\n";printArray(arr, n);// 调用冒泡排序函数bubbleSort(arr, n);// 打印排序后的数组cout << "排序后的数组:\n";printArray(arr, n);return 0;}```六、实验结果与分析1. 运行实验程序,输出排序前后的数组,验证排序结果是否正确。

微机排序实验实验报告

微机排序实验实验报告

一、实验目的1. 熟悉排序算法的基本原理和实现方法。

2. 掌握各种排序算法的性能特点。

3. 通过编程实现常见的排序算法,并进行性能测试和分析。

二、实验内容1. 实现以下排序算法:(1)冒泡排序(2)选择排序(3)插入排序(4)快速排序(5)归并排序2. 对生成的随机数据进行排序,并统计每种排序算法的运行时间。

3. 分析并比较各种排序算法的性能。

三、实验步骤1. 编写排序算法的代码。

(1)冒泡排序:通过比较相邻元素的大小,如果顺序错误则交换,重复这个过程,直到没有需要交换的元素。

(2)选择排序:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。

以此类推,直到所有元素均排序完毕。

(3)插入排序:将未排序的数据元素插入到已排序的有序序列中,从而得到一个新的、有序的序列。

(4)快速排序:通过一趟排序将待排序的记录分割成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序。

(5)归并排序:将两个或两个以上的有序表合并成一个新的有序表。

2. 生成随机数据,并进行排序。

3. 使用计时器统计每种排序算法的运行时间。

4. 分析并比较各种排序算法的性能。

四、实验结果与分析1. 实验数据生成1000个随机数,范围在1到10000之间。

2. 实验结果(1)冒泡排序:运行时间约为0.002秒。

(2)选择排序:运行时间约为0.003秒。

(3)插入排序:运行时间约为0.004秒。

(4)快速排序:运行时间约为0.0005秒。

(5)归并排序:运行时间约为0.001秒。

3. 性能分析(1)冒泡排序、选择排序和插入排序属于O(n^2)复杂度的排序算法,其运行时间随着数据量的增加而迅速增加。

(2)快速排序和归并排序属于O(nlogn)复杂度的排序算法,其运行时间随着数据量的增加而逐渐增加,但增长速度较慢。

排序方法实践实验心得体会

排序方法实践实验心得体会

排序方法实践实验心得体会排序算法是计算机科学中最基础也是最常用的算法之一,它的作用是将一组数据按照一定的顺序进行排列。

在我进行排序方法实践实验的过程中,我选择了几种常见的排序算法进行了比较和分析,并对每种算法的时间复杂度、空间复杂度以及稳定性进行了评估。

通过这次实验,我深刻理解了每种排序算法的原理和应用场景,并总结出了一些具体的心得和体会。

首先,我选择了冒泡排序算法。

它的原理是通过比较相邻的两个元素,将较大的元素逐渐交换到数组的末尾,从而实现整个数组的排序。

冒泡排序的时间复杂度是O(n^2),空间复杂度是O(1),算法的稳定性很好。

通过实验,我发现冒泡排序的性能在数据量很小时可以接受,但当数据量变大时,其效率明显不如其他排序算法。

其次,我实践了插入排序算法。

插入排序的原理是将数组分为两个区域,已排序区和未排序区,然后逐个将未排序区的元素插入到已排序区的合适位置。

插入排序的时间复杂度为O(n^2),空间复杂度为O(1),算法是稳定的。

在实验中,我发现插入排序在处理接近有序的数组时表现良好,但在处理逆序数组时效率较低。

接下来,我尝试了选择排序算法。

选择排序的原理是每次从未排序区中选择最小的元素,并与未排序区的第一个元素交换位置,从而逐渐将最小元素移到已排序区的末尾。

选择排序的时间复杂度为O(n^2),空间复杂度为O(1),算法是不稳定的。

通过实验,我发现选择排序的效率较低,因为它每次只能确定一个元素的位置。

最后,我实践了快速排序算法。

快速排序的原理是选择一个基准元素,然后将数组分为两个子数组,左边的元素都小于基准,右边的元素都大于基准,再递归地对子数组进行排序。

快速排序的时间复杂度为O(nlogn),空间复杂度取决于递归深度,算法是不稳定的。

通过实验,我发现快速排序的效率非常高,尤其在处理大规模数据时表现出色。

通过这次排序方法实践实验,我深入了解了各种排序算法的原理和性能特点。

在实验中,我发现不同的排序算法适用于不同的数据情况,选择合适的排序算法可以提高排序的效率。

实验 排序方法比较

实验  排序方法比较

实验四排序方法比较1.实验目的:掌握顺序表的常用排序方法,掌握一种计时方法。

2.实验内容:1)分别编写函数实现冒泡排序、快速排序和希尔排序算法;2)编制一个应用程序,它将随机产生的N个整数插入到一个顺序表中,然后分别用上述排序算法对这个顺序表进行排序;记录并显示各种方法的运行时间;3)以N=5000和N=50000运行这个应用程序,对算法运行的时间作比较和分析。

冒泡法排序:#include <stdio.h>#include <stdlib.h>#include <time.h>#define MaxSize 1000typedef int KeyType; /*关键字类型*/typedef char ElemType[1000]; /*其他数据项类型*/typedef struct{KeyType key; /*关键字域*/ElemType data; /*其他数据域*/} LineList; /*线性表元素类型*/void BubbleSort(LineList R[],int n){int i,j,exchange;LineList tmp;for (i=0;i<n-1;i++){ exchange=0;for (j=n-1;j>i;j--) /*比较,找出最小关键字的记录*/if (R[j].key<R[j-1].key){ tmp=R[j]; /*R[j]与R[j-1]进行交换,将最小关键字记录前移*/R[j]=R[j-1];R[j-1]=tmp;exchange=1;}if (exchange==0) /*本趟未发生交换时结束算法*/return;}}void main(){LineList R[MaxSize];clock_t start, end;double duration;KeyType a[1000];int n=1000,i;for (i=0;i<n;i++){ a[i]=rand();R[i].key=a[i];}start=clock();BubbleSort(R,n);end=clock();duration=(double)(end-start);printf("冒泡排序的时间");printf("%f",duration);}希尔法排序:#include <stdio.h>#include <stdlib.h>#include <time.h>#define MaxSize 1000typedef int KeyType; /*关键字类型*/typedef char ElemType[1000]; /*其他数据项类型*/typedef struct{KeyType key; /*关键字域*/ElemType data; /*其他数据域*/} LineList; /*线性表元素类型*/void ShellSort(LineList R[],int n){int i,j,gap;LineList tmp;gap=n/2; /*增量置初值*/while (gap>0){for (i=gap;i<n;i++) /*对所有相隔gap位置的所有元素组进行排序*/{tmp=R[i];j=i-gap;while (j>=0 && tmp.key<R[j].key)/*对相隔gap位置的元素组进行排序*/{R[j+gap]=R[j];j=j-gap; /*移到本组中的前一个元素*/}R[j+gap]=tmp;j=j-gap;}gap=gap/2; /*减小增量*/}}void main(){LineList R[MaxSize];clock_t start, end;double duration;KeyType a[1000];int n=1000,i;for (i=0;i<n;i++){ a[i]=rand();R[i].key=a[i];}start=clock();ShellSort(R,n);end=clock();duration=(double)(end-start);printf("希尔排序的时间");printf("%f",duration);}快速法排序:#include <stdio.h>#include <stdlib.h>#include <time.h>#define MaxSize 1000typedef int KeyType; /*关键字类型*/typedef char ElemType[1000]; /*其他数据项类型*/typedef struct{KeyType key; /*关键字域*/ElemType data; /*其他数据域*/} LineList; /*线性表元素类型*/void QuickSort(LineList R[],int s,int t) /*对R[s]至R[t]的元素进行快速排序*/{int i=s,j=t;LineList tmp;if (s<t) /*区间内至少存在一个元素的情况*/{ tmp=R[s]; /*用区间的第1个记录作为基准*/while (i!=j) /*从区间两端交替向中间扫描,直至i=j为止*/{ while (j>i && R[j].key>tmp.key)j--; /*从右向左扫描,找第1个关键字小于tmp.key的R[j]*/ R[i]=R[j]; /*找到这样的R[j],则R[i]和R[j]交换*/while (i<j && R[i].key<tmp.key)i++; /*从左向右扫描,找第1个关键字大于tmp.key的R[i]*/ R[j]=R[i]; /*找到这样的R[i],则R[i]和R[j]交换*/}R[i]=tmp;QuickSort(R,s,i-1); /*对左区间递归排序*/QuickSort(R,i+1,t); /*对右区间递归排序*/}}void main(){LineList R[MaxSize];clock_t start, end;double duration;KeyType a[1000];int n=1000,i;for (i=0;i<n;i++){ a[i]=rand();R[i].key=a[i];}start=clock();QuickSort(R,0,n-1);end=clock();duration=(double)(end-start);printf("快速排序的时间");printf("%f",duration);}实验体会快速排序方法最有效率。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验六各种排序方法的比较一、实验目的1.通过实验掌握排序的基本概念,对排序的稳定性及排序的时间复杂性有深刻的认识。

2.掌握各种排序方法的基本思想和算法实现。

3.能够灵活地选用某种排序方法解决问题。

二、实验要求1.认真阅读和掌握本实验的参考程序。

2.保存程序的运行结果,并结合程序进行分析。

三、实验内容编写一个程序,对所给的数据(程序中给出或通过键盘初始化均可)进行排序,要求尽可能多的选择不同的排序算法,并显示排序前和排序后的结果。

#include<stdio.h>#include<stdlib.h>#define TRUE 1#define FALSE 0#define N 10int a[10] = { 9,27,45,87,17,23,25,92,8,75 };typedef struct{int key;int info;}RecordNode;typedef struct Sort{int n; //记录个数RecordNode *record;}SortObject;/*直接插入排序*/void insertSort(SortObject *pvector){int i, j;RecordNode temp;for (i = 1; i < pvector->n; i++){temp = pvector->record[i]; j = i - 1;while ((temp.key < pvector->record[j].key) && (j >= 0)){pvector->record[j + 1] = pvector->record[j]; j--;}if (j != (i - 1)) pvector->record[j + 1] = temp;}}/*二分法插入排序*/void binSort(SortObject * pvector){int i, j, left, mid, right;RecordNode temp;for (i = 1; i < pvector->n; i++){temp = pvector->record[i]; left = 0; right = i - 1;while (left <= right){mid = (left + right) / 2;if (temp.key<pvector->record[mid].key) right = mid - 1;else left = mid + 1;}for (j = i - 1; j >= left; j--)pvector->record[j + 1] = pvector->record[j];if (left != i) pvector->record[left] = temp;}}struct Node;typedef struct Node ListNode;struct Node{int key;ListNode *next;};typedef ListNode * LinkList;void listSort(LinkList * plist){ListNode *now, *pre, *p, *q, *head;head = *plist;pre = head->next;if (pre == NULL) return;now = pre->next;if (now == NULL) return;while (now != NULL){q = head; p = head->next;while (p != now && p->key <= now->key) { q = p; p = p->next; }if (p == now) { pre = pre->next; now = pre->next; continue; }pre->next = now->next;q->next = now; now->next = p;now = pre->next;}}/*Shell排序*/void shellSort(SortObject * pvector, int d){ /* 按递增序进行Shell排序 */int i, j, increment;RecordNode temp;for (increment = d; increment > 0; increment /= 2){for (i = increment; i<pvector->n; i++){temp = pvector->record[i];j = i - increment;while (j >= 0 && temp.key<pvector->record[j].key){pvector->record[j + increment] = pvector->record[j];j -= increment;}pvector->record[j + increment] = temp;}}}/*直接选择排序*/void selectSort(SortObject * pvector){int i, j, k;RecordNode temp;for (i = 0; i < pvector->n - 1; i++){ /* 做n-1趟选择排序 */k = i;for (j = i + 1; j<pvector->n; j++) /* 在无序区内找出排序码最小的记录Rk*/if (pvector->record[j].key<pvector->record[k].key) k = j;if (k != i){ /* 记录Rk与Ri互换 */temp = pvector->record[i];pvector->record[i] = pvector->record[k];pvector->record[k] = temp;}}}/*起泡排序*/void bubbleSort(SortObject * pvector){int i, j, noswap;RecordNode temp;for (i = 0; i<pvector->n - 1; i++){noswap = TRUE;for (j = 0; j<pvector->n - i - 1; j++)if (pvector->record[j + 1].key<pvector->record[j].key){temp = pvector->record[j];pvector->record[j] = pvector->record[j + 1];pvector->record[j + 1] = temp;noswap = FALSE;}if (noswap) break;}}/*快速排序*/void quickSort(SortObject * pvector, int l, int r){int i, j;RecordNode temp;if (l >= r) return;i = l; j = r; temp = pvector->record[i];while (i != j){while ((pvector->record[j].key >= temp.key) && (j>i))j--;if (i<j) pvector->record[i++] = pvector->record[j];while ((pvector->record[i].key <= temp.key) && (j>i))i++;if (i<j) pvector->record[j--] = pvector->record[i];}pvector->record[i] = temp;quickSort(pvector, l, i - 1);quickSort(pvector, i + 1, r);}/*归并*/void merge(RecordNode* r, RecordNode *r1, int low, int m, int high) {int i, j, k;i = low; j = m + 1; k = low;while ((i <= m) && (j <= high)){if (r[i].key <= r[j].key) r1[k++] = r[i++];else r1[k++] = r[j++];}while (i <= m) r1[k++] = r[i++];while (j <= high) r1[k++] = r[j++];}void mergePass(RecordNode *r, RecordNode *r1, int n, int length) {int j, i = 0;while (i + 2 * length - 1<n){merge(r, r1, i, i + length - 1, i + 2 * length - 1);i += 2 * length;}if (i + length - 1<n - 1)merge(r, r1, i, i + length - 1, n - 1);elsefor (j = i; j<n; j++) r1[j] = r[j];}/*二路归并排序*/void mergeSort(SortObject *pvector){RecordNode record[N];int length = 1;while (length<pvector->n){mergePass(pvector->record, record, pvector->n, length); /* 一趟归并,结果放在r1中*/length *= 2;mergePass(record, pvector->record, pvector->n, length); /* 一趟归并,结果放在r中 */length *= 2;}}void s1()/* 直接插入排序 */{int i;SortObject *p1 = (SortObject *)malloc(sizeof(SortObject));p1->n = 10;p1->record = (RecordNode *)malloc(sizeof(RecordNode)*p1->n);for (i = 0; i<p1->n; i++)p1->record[i].key = a[i];insertSort(p1);printf("直接插入排序后 : ");for (i = 0; i<p1->n; i++)printf("%d ", p1->record[i].key);printf("\n");}void s2()/* 二分法插入排序 */{int i;SortObject *p2 = (SortObject *)malloc(sizeof(SortObject));p2->n = 10;p2->record = (RecordNode *)malloc(sizeof(RecordNode)*p2->n);for (i = 0; i<p2->n; i++)p2->record[i].key = a[i];binSort(p2);printf("二分法插入排序后: ");for (i = 0; i<p2->n; i++)printf("%d ", p2->record[i].key);printf("\n");}void s3()/* Shell排序 */{int i;SortObject *p3 = (SortObject *)malloc(sizeof(SortObject));p3->n = 10;p3->record = (RecordNode *)malloc(sizeof(RecordNode)*p3->n);for (i = 0; i<p3->n; i++)p3->record[i].key = a[i];shellSort(p3, 4);printf("Shell排序后 : ");for (i = 0; i<p3->n; i++)printf("%d ", p3->record[i].key);printf("\n");}void s4()/* 直接选择排序 */{int i;SortObject *p4 = (SortObject *)malloc(sizeof(SortObject));p4->n = 10;p4->record = (RecordNode *)malloc(sizeof(RecordNode)*p4->n);for (i = 0; i<p4->n; i++)p4->record[i].key = a[i];selectSort(p4);printf("直接选择排序后 : ");for (i = 0; i<p4->n; i++)printf("%d ", p4->record[i].key);printf("\n");}void s5()/* 起泡排序 */{int i;SortObject *p5 = (SortObject *)malloc(sizeof(SortObject));p5->n = 10;p5->record = (RecordNode *)malloc(sizeof(RecordNode)*p5->n);for (i = 0; i<p5->n; i++)p5->record[i].key = a[i];bubbleSort(p5);printf("起泡排序后 : ");for (i = 0; i<p5->n; i++)printf("%d ", p5->record[i].key);printf("\n");}void s6()/* 快速排序 */{int i;SortObject *p6 = (SortObject *)malloc(sizeof(SortObject));p6->n = 10;p6->record = (RecordNode *)malloc(sizeof(RecordNode)*p6->n);for (i = 0; i<p6->n; i++)p6->record[i].key = a[i];quickSort(p6, 0, p6->n - 1);printf("快速排序后 : ");for (i = 0; i<p6->n; i++)printf("%d ", p6->record[i].key);printf("\n");}void s7()/* 二路归并排序 */{int i;SortObject *p7 = (SortObject *)malloc(sizeof(SortObject));p7->n = 10;p7->record = (RecordNode *)malloc(sizeof(RecordNode)*p7->n);for (i = 0; i<p7->n; i++)p7->record[i].key = a[i];mergeSort(p7);printf("二路归并排序后 : ");for (i = 0; i<p7->n; i++)printf("%d ", p7->record[i].key);printf("\n");}void main(){int i, b;printf("初始顺序 : ");for (i = 0; i<10; i++)printf("%d ", a[i]);printf("\n\n");printf("********操作选项********\n\n");printf(" 1.直接插入排序\n");printf(" 2.二分法插入排序\n");printf(" 3.Shell排序\n");printf(" 4.直接选择排序\n");printf(" 5.冒泡排序\n");printf(" 6.快速排序 \n");printf(" 7.二路归并排序\n");printf(" 0.退出操作\n");printf("************************");printf(" \n 请输入你需要操作的序号: ");scanf("%d", &b);printf("\n\n");while (1){switch (b){case 1: /* 直接插入排序 */s1();break;case 2: /* 二分法插入排序 */s2();break;case 3: /* Shell排序 */s3();break;case 4: /* 直接选择排序 */s4();break;case 5: /* 起泡排序 */s5();break;case 6: /* 快速排序 */s6();break;case 7: /* 二路归并排序 */s7();break;case 0:exit(0);}printf(" \n 请继续选择一个序号");scanf("%d", &b);printf("\n");}}。

相关文档
最新文档