实验 各种排序方法的比较

合集下载

内部排序比较 (实验报告+源程序)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);}实验体会快速排序方法最有效率。

内部排序比较 (实验报告+源程序)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错误调试无。

查找、排序的应用 实验报告

查找、排序的应用 实验报告

实验七查找、排序的应用一、实验目的1、本实验可以使学生更进一步巩固各种查找和排序的基本知识。

2、学会比较各种排序与查找算法的优劣。

3、学会针对所给问题选用最适合的算法。

4、掌握利用常用的排序与选择算法的思想来解决一般问题的方法和技巧。

二、实验内容[问题描述]对学生的基本信息进行管理。

[基本要求]设计一个学生信息管理系统,学生对象至少要包含:学号、姓名、性别、成绩1、成绩2、总成绩等信息。

要求实现以下功能:1.总成绩要求自动计算;2.查询:分别给定学生学号、姓名、性别,能够查找到学生的基本信息(要求至少用两种查找算法实现);3.排序:分别按学生的学号、成绩1、成绩2、总成绩进行排序(要求至少用两种排序算法实现)。

[测试数据]由学生依据软件工程的测试技术自己确定。

三、实验前的准备工作1、掌握哈希表的定义,哈希函数的构造方法。

2、掌握一些常用的查找方法。

1、掌握几种常用的排序方法。

2、掌握直接排序方法。

四、实验报告要求1、实验报告要按照实验报告格式规范书写。

2、实验上要写出多批测试数据的运行结果。

3、结合运行结果,对程序进行分析。

五、算法设计a、折半查找设表长为n,low、high和mid分别指向待查元素所在区间的下界、上界和中点,key为给定值。

初始时,令low=1,high=n,mid=(low+high)/2,让key与mid指向的记录比较,若key==r[mid].key,查找成功若key<r[mid].key,则high=mid-1若key>r[mid].key,则low=mid+1重复上述操作,直至low>high时,查找失败b、顺序查找从表的一端开始逐个进行记录的关键字和给定值的比较。

在这里从表尾开始并把下标为0的作为哨兵。

void chaxun(SqList &ST) //查询信息{ cout<<"\n************************"<<endl;cout<<"~ (1)根据学号查询 ~"<<endl;cout<<"~ (2)根据姓名查询 ~"<<endl;cout<<"~ (3)根据性别查询 ~"<<endl;cout<<"~ (4)退出 ~"<<endl;cout<<"************************"<<endl; if(m==1) 折半查找算法:for(int i=1;i<ST.length;i++)//使学号变为有序for(int j=i;j>=1;j--)if(ST.r[j].xuehao<ST.r[j-1].xuehao){LI=ST.r[j];ST.r[j]=ST.r[j-1];ST.r[j-1]=LI;}int a=0;cout<<"输入要查找的学号"<<endl;cin>>n;int low,high,mid;low=0;high=ST.length-1; // 置区间初值while (low<=high){mid=(low+high)/2;if(n==ST.r[mid].xuehao){cout<<ST.r[mid].xuehao<<""<<ST.r[mid].xingming<<""<<ST.r[mid].xingbei<<""<<ST.r[mid].chengji1<<""<<ST.r[mid].chengji2<<""<<ST.r[mid].zong<<endl;a=1;break;}else if(n<ST.r[mid].xuehao )high=mid-1; // 继续在前半区间进行查找elselow=mid+1; // 继续在后半区间进行查找顺序查找算法:cout<<"输入要查找的姓名"<<endl;cin>>name;for(int i=0;i<ST.length;i++){if(name==ST.r[i].xingming){cout<<ST.r[i].xuehao<<""<<ST.r[i].xingming<<""<<ST.r[i].xingbei<<""<<ST.r[i].chengji1<<""<<ST.r[i].chengji2<<""<<ST.r[i].zong<<endl;a=1;}1、插入排序每步将一个待排序的记录,按其关键码大小,插入到前面已经排好序的一组记录的适当位置上,直到记录全部插入为止。

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

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

《数据结构与算法》实验报告一、需求分析问题描述:在教科书中,各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶,或大概执行时间。

试通过随机数据比较各算法的关键字比较次数和关键字移动次数,以取得直观感受。

基本要求:(l)对以下6种常用的内部排序算法进行比较:起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序。

(2)待排序表的表长不小于100000;其中的数据要用伪随机数程序产生;至少要用5组不同的输入数据作比较;比较的指标为有关键字参加的比较次数和关键字的移动次数(关键字交换计为3次移动)。

(3)最后要对结果作简单分析,包括对各组数据得出结果波动大小的解释。

数据测试:二.概要设计1.程序所需的抽象数据类型的定义:typedef int BOOL; //说明BOOL是int的别名typedef struct StudentData { int num; //存放关键字}Data; typedef struct LinkList { int Length; //数组长度Data Record[MAXSIZE]; //用数组存放所有的随机数} LinkList int RandArray[MAXSIZE]; //定义长度为MAXSIZE的随机数组void RandomNum() //随机生成函数void InitLinkList(LinkList* L) //初始化链表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, int* CmpNum, int* ChgNum) //快速排序void HeapSort (LinkList* L, int* CmpNum, int* ChgNum) //堆排序void BubbleSort(LinkList* L, int* CmpNum, int* ChgNum) //冒泡排序void SelSort(LinkList* L, int* CmpNum, int* ChgNum) //选择排序void Compare(LinkList* L,int* CmpNum, int* ChgNum) //比较所有排序2 .各程序模块之间的层次(调用)关系:二、详细设计typedef int BOOL; //定义标识符关键字BOOL别名为int typedef struct StudentData //记录数据类型{int num; //定义关键字类型}Data; //排序的记录数据类型定义typedef struct LinkList //记录线性表{int Length; //定义表长Data Record[MAXSIZE]; //表长记录最大值}LinkList; //排序的记录线性表类型定义int RandArray[MAXSIZE]; //定义随机数组类型及最大值/******************随机生成函数********************/void RandomNum(){int i; srand((int)time(NULL)); //用伪随机数程序产生伪随机数for(i=0; i小于MAXSIZE; i++) RandArray[i]<=(int)rand(); 返回;}/*****************初始化链表**********************/void InitLinkList(LinkList* L) //初始化链表{int i;memset(L,0,sizeof(LinkList));RandomNum();for(i=0; i小于<MAXSIZE; i++)L->Record[i].num<=RandArray[i]; L->Length<=i;}BOOL LT(int i, int j,int* CmpNum){(*CmpNum)++; 若i<j) 则返回TRUE; 否则返回FALSE;}void Display(LinkList* L){FILE* f; //定义一个文件指针f int i;若打开文件的指令不为空则//通过文件指针f打开文件为条件判断{ //是否应该打开文件输出“can't open file”;exit(0); }for (i=0; i小于L->Length; i++)fprintf(f,"%d\n",L->Record[i].num);通过文件指针f关闭文件;三、调试分析1.调试过程中遇到的问题及经验体会:在本次程序的编写和调试过程中,我曾多次修改代码,并根据调试显示的界面一次次调整代码。

排序算法设计实验报告总结

排序算法设计实验报告总结

排序算法设计实验报告总结1. 引言排序算法是计算机科学中最基础的算法之一,它的作用是将一组数据按照特定的顺序进行排列。

在现实生活中,我们经常需要对一些数据进行排序,比如学生成绩的排名、图书按照标题首字母进行排序等等。

因此,了解不同的排序算法的性能特点以及如何选择合适的排序算法对于解决实际问题非常重要。

本次实验旨在设计和实现几种经典的排序算法,并对其进行比较和总结。

2. 实验方法本次实验设计了四种排序算法,分别为冒泡排序、插入排序、选择排序和快速排序。

实验采用Python语言进行实现,并通过编写测试函数对算法进行验证。

测试函数会生成一定数量的随机数,并对这些随机数进行排序,统计算法的执行时间和比较次数,最后将结果进行记录和分析。

3. 测试结果及分析3.1 冒泡排序冒泡排序是一种简单且常用的排序算法,其基本思想是从待排序的数据中依次比较相邻的两个元素,如果它们的顺序不符合要求,则交换它们的位置。

经过多轮的比较和交换,最小值会逐渐冒泡到前面。

测试结果显示,冒泡排序在排序1000个随机数时,平均执行时间为0.981秒,比较次数为499500次。

从执行时间和比较次数来看,冒泡排序的性能较差,对于大规模数据的排序不适用。

3.2 插入排序插入排序是一种简单但有效的排序算法,其基本思想是将一个待排序的元素插入到已排序的子数组中的正确位置。

通过不断将元素插入到正确的位置,最终得到排序好的数组。

测试结果显示,插入排序在排序1000个随机数时,平均执行时间为0.892秒,比较次数为249500次。

插入排序的性能较好,因为其内层循环的比较次数与待排序数组的有序程度相关,对于近乎有序的数组排序效果更好。

3.3 选择排序选择排序是一种简单但低效的排序算法,其基本思想是在待排序的数组中选择最小的元素,将其放到已排序数组的末尾。

通过多次选择和交换操作,最终得到排序好的数组。

测试结果显示,选择排序在排序1000个随机数时,平均执行时间为4.512秒,比较次数为499500次。

重量的比较与排序

重量的比较与排序

重量的比较与排序重量是一种非常常见的度量单位,它用来衡量物体的质量或重度。

在生活中,我们经常需要比较和排序物体的重量,无论是在购物、搬运货物还是进行实验研究等方面。

本文将讨论重量的比较与排序方法,以及应用领域中的相关问题。

一、重量的比较方法1. 直观比较法直观比较法是最简单直接的一种比较方法,通过观察物体的大小、厚度、材质等特征,来估计物体的重量大小。

这种方法对于非常相似的物体比较有效,但在对于差异较大的物体进行比较时,结果可能会产生误判。

2. 使用天平天平是一种经典的用来比较物体重量的工具。

将待比较的物体分别放在两个不同的托盘上,通过调整天平来使两边保持平衡。

根据天平两边托盘上的位置高低可以判断物体的重量大小。

这种方法适用于较小、较轻的物体比较。

3. 使用电子秤或磅秤电子秤或磅秤是一种更为精确的测量重量的工具。

通过将物体放在秤盘上,数值会直接显示物体的重量。

电子秤或磅秤一般具有较高的准确性,适用于各种不同重量范围的物体。

4. 使用风力秤或浮力秤风力秤和浮力秤是利用风的力量或物体在液体中的浮力来测量物体重量的工具。

风力秤通过测量物体所需的风力大小来推算其重量,浮力秤则是通过物体的浸没深度和所处液体的密度来计算重量。

这种方法适用于特殊场景中无法直接接触物体的情况,例如测量大型船只的重量或测定潜水装备的质量。

二、重量的排序方法1. 顺序比较法顺序比较法是一种常用的排序方法,通过将待排序的物体两两进行比较,逐步确定其重量顺序。

例如,将物体放在天平上进行比较,对于每一对物体,记录下比较结果,然后将重的物体放在一边,轻的物体放在另一边,继续进行比较,直到所有物体都被比较完毕,最终得到排序结果。

2. 分组比较法分组比较法是将待排序的物体分成多组进行比较,再将每组中重量最大的物体与其他组中最小的物体进行比较,逐步确定整体排序结果。

这种方法可以减少比较的次数和步骤,提高排序效率。

3. 堆排序堆排序是一种基于完全二叉树的排序方法,它通过建立一个二叉堆结构,并根据堆顶元素的大小进行排序。

排序算法实验报告

排序算法实验报告

数据结构实验报告八种排序算法实验报告一、实验内容编写关于八种排序算法的C语言程序,要求包含直接插入排序、希尔排序、简单项选择择排序、堆排序、冒泡排序、快速排序、归并排序和基数排序。

二、实验步骤各种内部排序算法的比较:1.八种排序算法的复杂度分析〔时间与空间〕。

2.八种排序算法的C语言编程实现。

3.八种排序算法的比较,包括比较次数、移动次数。

三、稳定性,时间复杂度和空间复杂度分析比较时间复杂度函数的情况:时间复杂度函数O(n)的增长情况所以对n较大的排序记录。

一般的选择都是时间复杂度为O(nlog2n)的排序方法。

时间复杂度来说:(1)平方阶(O(n2))排序各类简单排序:直接插入、直接选择和冒泡排序;(2)线性对数阶(O(nlog2n))排序快速排序、堆排序和归并排序;(3)O(n1+§))排序,§是介于0和1之间的常数。

希尔排序(4)线性阶(O(n))排序基数排序,此外还有桶、箱排序。

说明:当原表有序或基本有序时,直接插入排序和冒泡排序将大大减少比较次数和移动记录的次数,时间复杂度可降至O〔n〕;而快速排序则相反,当原表基本有序时,将蜕化为冒泡排序,时间复杂度提高为O〔n2〕;原表是否有序,对简单项选择择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。

稳定性:排序算法的稳定性:假设待排序的序列中,存在多个具有相同关键字的记录,经过排序,这些记录的相对次序保持不变,则称该算法是稳定的;假设经排序后,记录的相对次序发生了改变,则称该算法是不稳定的。

稳定性的好处:排序算法如果是稳定的,那么从一个键上排序,然后再从另一个键上排序,第一个键排序的结果可以为第二个键排序所用。

基数排序就是这样,先按低位排序,逐次按高位排序,低位相同的元素其顺序再高位也相同时是不会改变的。

另外,如果排序算法稳定,可以防止多余的比较;稳定的排序算法:冒泡排序、插入排序、归并排序和基数排序不是稳定的排序算法:选择排序、快速排序、希尔排序、堆排序四、设计细节排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。

排序实验报告

排序实验报告

重庆交通大学设计性实验报告班级: 2013级2班学号:姓名:旧城余约实验项目名称:排序实验项目性质:设计性实验实验所属课程:算法与数据结构实验室(中心): B01-407 指导教师:鲁云平实验完成时间: 2015 年 6 月 7 日一、实验目的1、熟悉内排序方法;2、领会排序过程;3、比较各种排序方法之间的差异。

二、实验内容及要求1、随机产生100个整数;2、使用不同的内排序方法对其排序;3、领会排序过程。

三、实验设备及软件电脑,visual c++ 6.0四、实验过程及步骤运行环境:Visual C++6.0;实现思路:本次实验是对随机产生的一百个数进行排序,直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、直接选择排序、堆排序、归并排序、基数排序这几个排序方法,下面是对这几个排序方法的解释:首先,在我的排序类的书写中,我采用的数组的存储方式,raw_data[N+1]存储原始数据,handle_data[N+1]表示处理数据,我的原意是在进行排序时,不打乱原来系统随机产生的那一百个数,这样每次在选择排序方式时都时没有处理过的数据。

每次在进行排序操作之前,都有复制操作。

数组类型是自定义类型Srec<T>,里面包含排序关键码key,因为是整数,便没有其他域。

1、Sort()构造函数,我的程序中,系统随机产生100个整数便在构造函数中进行,随机产生整数是用0+(int)10000*rand()/(RAND_MAX+1)实现,表示产生0~10000之间的整数,并赋值给raw_data[N+1],同时复制给handle_data[N+1]进行初始化,但这两个数组中第一个存储空间作为中间量使用,数据存储是从第二个位置开始。

2、void OutPut()输出排序表,即将数组handle_data[N+1]输出。

3、void InsertSort()直接插入排序,它的基本思路是每一趟将一个待排序的数据,按其大小插入到已经排序的部分中适当的位置,直到全部插入完成;具体做法为:当插入第i(i>1)个数据时,前面的r[1],r[2],…,r[i-1]已经排好序,这时,用r[i]的数据与r[i-1],r[i-2],…的数据顺序进行比较,找到插入位置,即将r[i]插入,原来位置上的对象依次向后移动。

数据排序实验实验报告

数据排序实验实验报告

一、实验目的1. 熟悉数据排序的基本概念和算法。

2. 掌握几种常见的排序算法(冒泡排序、选择排序、插入排序、快速排序、归并排序等)的实现方法。

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

4. 比较不同排序算法的效率,了解其适用场景。

二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.83. 软件工具:PyCharm三、实验内容1. 实现冒泡排序、选择排序、插入排序、快速排序、归并排序等排序算法。

2. 对一组随机生成的数据进行排序,并记录每种排序算法的运行时间。

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

4. 比较不同排序算法的效率,了解其适用场景。

四、实验步骤1. 实现排序算法(1)冒泡排序```pythondef bubble_sort(arr):n = len(arr)for i in range(n):for j in range(0, n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j] return arr```(2)选择排序```pythondef selection_sort(arr):n = len(arr)for i in range(n):min_idx = ifor j in range(i+1, n):if arr[min_idx] > arr[j]:min_idx = jarr[i], arr[min_idx] = arr[min_idx], arr[i] return arr```(3)插入排序```pythondef insertion_sort(arr):for i in range(1, len(arr)):key = arr[i]j = i-1while j >=0 and key < arr[j]:arr[j+1] = arr[j]j -= 1arr[j+1] = keyreturn arr```(4)快速排序```pythondef quick_sort(arr):if len(arr) <= 1:return arrpivot = arr[len(arr) // 2]left = [x for x in arr if x < pivot]middle = [x for x in arr if x == pivot]right = [x for x in arr if x > pivot]return quick_sort(left) + middle + quick_sort(right) ```(5)归并排序```pythondef merge_sort(arr):if len(arr) <= 1:return arrmid = len(arr) // 2left = merge_sort(arr[:mid])right = merge_sort(arr[mid:])return merge(left, right)def merge(left, right):result = []i = j = 0while i < len(left) and j < len(right):if left[i] < right[j]:result.append(left[i])i += 1else:result.append(right[j])j += 1result.extend(left[i:])result.extend(right[j:])return result```2. 对一组随机生成的数据进行排序,并记录每种排序算法的运行时间```pythonimport randomimport timedef test_sort_algorithms():arr = [random.randint(0, 1000) for _ in range(1000)]print("Original array:", arr)print("Bubble Sort:", bubble_sort(arr.copy()))print("Selection Sort:", selection_sort(arr.copy()))print("Insertion Sort:", insertion_sort(arr.copy()))print("Quick Sort:", quick_sort(arr.copy()))print("Merge Sort:", merge_sort(arr.copy()))def measure_time(sort_function, arr):start_time = time.time()sort_function(arr)end_time = time.time()return end_time - start_timedef compare_sort_algorithms():arr = [random.randint(0, 1000) for _ in range(1000)]bubble_time = measure_time(bubble_sort, arr.copy())selection_time = measure_time(selection_sort, arr.copy()) insertion_time = measure_time(insertion_sort, arr.copy()) quick_time = measure_time(quick_sort, arr.copy())merge_time = measure_time(merge_sort, arr.copy())print("Bubble Sort Time:", bubble_time)print("Selection Sort Time:", selection_time)print("Insertion Sort Time:", insertion_time)print("Quick Sort Time:", quick_time)print("Merge Sort Time:", merge_time)if __name__ == "__main__":test_sort_algorithms()compare_sort_algorithms()```3. 分析各种排序算法的时间复杂度和空间复杂度(1)冒泡排序:时间复杂度O(n^2),空间复杂度O(1)(2)选择排序:时间复杂度O(n^2),空间复杂度O(1)(3)插入排序:时间复杂度O(n^2),空间复杂度O(1)(4)快速排序:平均时间复杂度O(nlogn),最坏时间复杂度O(n^2),空间复杂度O(logn)(5)归并排序:时间复杂度O(nlogn),空间复杂度O(n)4. 比较不同排序算法的效率,了解其适用场景通过比较实验结果,可以发现:- 在数据规模较小的情况下,冒泡排序、选择排序、插入排序等简单排序算法的效率较高。

各种排序算法比较课程设计

各种排序算法比较课程设计

各种排序算法比较课程设计一、课程目标知识目标:1. 学生能理解并掌握冒泡排序、选择排序、插入排序等基本排序算法的原理与实现步骤。

2. 学生能够比较不同排序算法的时间复杂度和空间复杂度,并分析其优缺点。

3. 学生了解排序算法在实际应用中的重要性,能够举例说明。

技能目标:1. 学生能够运用编程语言(如Python、C++等)实现不同排序算法,并解决实际问题。

2. 学生具备分析排序算法性能的能力,能够根据实际问题选择合适的排序算法。

情感态度价值观目标:1. 学生对排序算法产生兴趣,认识到算法在计算机科学中的重要作用。

2. 学生通过合作学习,培养团队协作精神和沟通能力。

3. 学生在解决实际问题的过程中,培养勇于挑战、持续优化的精神。

课程性质:本课程为计算机科学领域的一门核心课程,旨在帮助学生掌握基本排序算法,提高编程能力和问题解决能力。

学生特点:六年级学生,已具备一定的编程基础,对算法有一定了解,但尚需深入学习和实践。

教学要求:结合学生特点和课程性质,将课程目标分解为具体的学习成果,注重实践操作和团队合作,以提高学生的编程能力和算法思维。

二、教学内容1. 冒泡排序:原理讲解,实现步骤,代码实践,性能分析。

- 课本章节:第三章第二节“冒泡排序”2. 选择排序:原理讲解,实现步骤,代码实践,性能分析。

- 课本章节:第三章第三节“选择排序”3. 插入排序:原理讲解,实现步骤,代码实践,性能分析。

- 课本章节:第三章第四节“插入排序”4. 排序算法比较:时间复杂度、空间复杂度分析,优缺点对比。

- 课本章节:第三章第五节“排序算法的比较与应用”教学进度安排:第一课时:冒泡排序原理讲解与代码实践。

第二课时:选择排序原理讲解与代码实践。

第三课时:插入排序原理讲解与代码实践。

第四课时:排序算法性能分析,优缺点对比,实际应用案例讨论。

教学内容确保科学性和系统性,结合课本章节,让学生在实践中掌握排序算法,并通过比较分析,深入理解排序算法的内涵。

实验报告七

实验报告七

对偶比较法和等级排列法1. 引言顺序量表的建立方法有两种,等级排列法和对偶比较法,等级排列法的特点是一次性地将需要比较的刺激同时呈现给被试,请被试按照一定标准把这些刺激排序。

主试将多个被试对同一刺激的评定等级加以平均,就能求出每一刺激的各自平均等级,最后把各刺激按平均等级排出的顺序就是一顺序量表。

对偶比较法则是把所有的刺激配成对,然后一对一对的呈现,让被试依据刺激的某一特性进行比较,并作出判断。

最后按每个刺激各自明显于其他的刺激的百分比的大小排列成序,即可制作一个顺序量表。

在对偶比较法中,要注意同一刺激对需要比较两次,前后两次的呈现要在时间和空间位置上进行平衡。

所有的刺激对呈现的顺序也要按照台阶式或斜线式的方法进行安排。

本次实验目的是通过对5种图片的爱好程度的测定,学习如何用对偶比较法和等级排列法制作心理量表。

2. 方法2.1 被试本次实验的被试为五名大二的本科生,女,21岁。

2.2 仪器5种不同的图片。

2.3 程序(一)对偶比较法(1)按台阶式排出呈现刺激的顺序,见表7.1。

(2)给被试如下的指导语:“我每次都给你看两张图片,请你告诉我你喜欢哪一张。

”(3)每次都要将这两张同时放到被试前面的桌面固定位置上,一左一右。

被试的反应要记到记录表相应的位置上。

做完10次休息2min,然后再用相反的顺序比较10次,这10次每两张图片的呈现的位置要和前面呈现时的左右位置调换一下。

对偶比较法的被试只需1名(非等级排列法的被试)。

(二) 等级排列法(1)排定呈现5种图片的顺序,见表7.2。

(2)给被试如下的指导语:“请你做一个图片爱好的实验,这里有5张不同颜色的图片(将图片放到桌面上),要求你按照自己喜爱的程度排列一个顺序:将最喜欢的图片放在最左边,最不喜欢的放在最右边,其余的3张,按自己喜欢的程度依次排列在两者之间。

如果你排好后觉得还不满意,可以再改,直到你觉得满意为止。

这个实验无所谓对错,只要你能按照自己对某种物品的喜好程度排序就行。

排序C++程序实验报告

排序C++程序实验报告

数据结构实验报告实验名称:实验四——排序学生姓名:班级:班内序号:学号:日期:1.实验要求使用简单数组实现下面各种排序算法,并进行比较。

排序算法:1、插入排序2、希尔排序3、冒泡排序4、快速排序5、简单选择排序6、堆排序(选作)7、归并排序(选作)8、基数排序(选作)9、其他要求:1、测试数据分成三类:正序、逆序、随机数据2、对于这三类数据,比较上述排序算法中关键字的比较次数和移动次数(其中关键字交换计为3次移动)。

3、对于这三类数据,比较上述排序算法中不同算法的执行时间,精确到微秒(选作)4、对2和3的结果进行分析,验证上述各种算法的时间复杂度编写测试main()函数测试线性表的正确性。

2. 程序分析插入排序类似于玩纸牌时整理手中纸牌的过程,它的基本方法是寻找一个指定元素在待排序元素中的位置,然后插入。

直接插入排序的基本思想可以这样描述:每次讲一个待排序的元素按其关键码的大小插入到一个已经排序好的有序序列中,直到全部元素排序好。

元素个数为1时必然有序,这就是初始有序序列;可以采用顺序查找的方法查找插入点,为了提高时间效率,在顺序查找过程中边查找边后移的策略完成一趟插入。

希尔排序又称“缩小增量排序”,是对直接插入排序的一种改进,它利用了直接插入的两个特点:1.基本有序的序列,直接插入最快;2.记录个数很少的无序序列,直接插入也很快。

希尔排序的基本思想为:将待排序的元素集分成多个子集,分别对这些子集进行直接插入排序,待整个序列基本有序时,再对元素进行一次直接插入排序。

冒泡排序的基本思想是:两两比较相邻的元素,如果反序,则交换位置,直到没有反序的元素为止。

具体的排序过程是:将整个待排序元素划分成有序区和无序区,初始状态有序区为空,无序区包括所有待排序的元素;对无序区从前向后依次将相邻元素的关键码进行比较,若反序则交换,从而使得关键码小的元素向前移,关键码大的元素向后移;重复执行前一个步骤,直到无序区中没有反序的元素。

  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");}}。

相关文档
最新文档