广东工业大学_数据结构(内部排序算法)实验报告

合集下载

广工数据结构实验设计报告BTree

广工数据结构实验设计报告BTree

数据结构设计性实验报告课程名称数据结构实验题目名称B树(难度1.4)学生学院计算机学院专业班级学号姓名指导教师黄剑锋2015年 06月25日B树抽象数据类型实现一、设计简介本次设计在AnyviewCL自由编程平台上实现了B树的6种基本操作,并根据这个基本操作设计了友好的交际界面,操作简单易懂,并在AnyviewCL自由编程平台上可视化测试B树各个基本操作,保证了各基本的操作算法的正确性。

经在AnyviewCL自由编程平台严格测试后,将本设计移植到Visual C++ 6.0平台生成可运行程序,并进行各个基本操作的测试,保证了程序运行的稳定性。

其中数据来源为一组在0~1000内的int型随机数,但数据由typedefintKeyType定义,若需要改变数据类型,只需要将int替换成所需的数据类型即可。

二、抽象数据类型定义及各种基本操作的描述ADT BTree{数据对象:D是具有相同特征的数据元素集合。

数据关系:若D为空集,则称为空树;(1)树中每个结点最多含有m棵子树;(2)若根结点不是叶子结点,则至少有2个子树;(3)除根结点之外的所有非终端结点至少有┌m/2┐棵子树;(4)每个非终端结点中包含信息:(n,A0,K1,A1,K2,A2,…,Kn,An)。

其中:1)Ki(1<=i<=n)为关键字,且关键字按升序排序;2)指针Ai(0<=i<=n)指向子树的根结点,Ai-1指向子树中所有结点的关键字均小于Ki,且大于Ki-1;3)关键字的个数n必须满足:┌m/2┐-1<=n<=m-1。

(5)所有的叶子节点都在同一层,子叶结点不包含任何信息。

基本操作P:CreatBTree(&T, n, m);初始条件:初始化关键字个数n大于等于0,B树的阶数m大于3小于等于20。

操作结果:构建一棵阶数为m,含有n个关键字的B树。

SearchBTree(T, k, &p);初始条件:树T存在。

内部排序实验报告总结

内部排序实验报告总结

内部排序实验报告总结内部排序实验报告总结一、引言内部排序是指对一个存储在计算机内存中的数据集合进行排序的过程。

在本次实验中,我们对常见的内部排序算法进行了实验比较,包括冒泡排序、选择排序、插入排序、希尔排序、归并排序和快速排序。

通过比较这些算法的执行时间和空间复杂度,我们可以评估它们在不同数据集上的性能。

二、实验目的1. 比较不同内部排序算法在不同数据集上的性能差异;2. 了解各种内部排序算法的实现原理;3. 掌握如何分析和评估算法的时间复杂度和空间复杂度。

三、实验方法1. 实验环境:使用具有相同硬件配置和操作系统版本的计算机进行测试。

2. 实验数据:选择多个不同大小和特征的数据集进行测试,包括随机数列、有序数列和逆序数列。

3. 实验步骤:3.1 实现各个内部排序算法;3.2 对每个数据集分别运行各个算法,并记录执行时间;3.3 分析结果并比较各个算法之间的性能差异。

四、实验结果与分析1. 冒泡排序:冒泡排序是一种简单的排序算法,它重复地遍历要排序的数列,一次比较两个元素,并按照大小交换它们的位置。

经过多次遍历,最大(或最小)的元素会逐渐移动到数列的末尾。

冒泡排序的时间复杂度为O(n^2),空间复杂度为O(1)。

在本次实验中,冒泡排序在随机数列上表现良好,但在有序数列和逆序数列上性能较差。

这是因为冒泡排序需要进行多次交换操作,而有序数列和逆序数列中元素已经接近或完全有序,交换操作并不频繁。

2. 选择排序:选择排序是一种简单直观的排序算法,它每次从待排序的数据中选择最小(或最大)的元素,并将其放到已排好序的部分末尾。

选择排序的时间复杂度为O(n^2),空间复杂度为O(1)。

实验结果显示,选择排序在各种数据集上都表现稳定。

这是因为选择排序每次只需进行一次交换操作,相对于冒泡排序来说更加高效。

3. 插入排序:插入排序是一种简单直观且稳定的内部排序算法,它将待排序的数据分为已排序和未排序两部分,每次从未排序部分取出一个元素,插入到已排序部分的适当位置。

广东工业大学算法设计实验报告

广东工业大学算法设计实验报告

算法设计分析实验报告专业班级软件工程4班学号3111006218姓名陈雪桂授课教师(2014年06月)成绩目录一、实验目的 (3)二、实验环境 (3)三、实验内容 (3)(1)实验内容 (3)实验一 (3)实验二 (3)(2)算法设计思想 (4)实验一 (4)实验二 (4)(3)程序设计 (4)实验一 (4)实验二 (10)(4)数据输入和结果输出 (12)实验一 (12)实验二 (13)(5)算法复杂性分析 (13)实验二 (13)四、实验心得与小结 (13)五、指导教师成绩评定 (13)一、实验目的1.掌握算法复杂性概念。

2.理解影响算法时间复杂性的因素。

3.理解渐进时间复杂性的概念。

4. 掌握分析算法复杂度的方法。

二、实验环境MyEclipse三、实验内容(1)实验内容实验一理解分治法的效率,用分治法完成快包算法,并给出一个运行实例。

实验二通过键盘输入一个高精度的正整数n(n的有效位数≤240),去掉其中任意s个数字后,剩下的数字按原左右次序将组成一个新的正整数。

编程对给定的n 和s,寻找一种方案,使得剩下的数字组成的新数最小。

【样例输入】178543S=4【样例输出】13实现该算法,分析算法的效率。

并给出一个运行实例:n=“你的学号”,s=7。

(2)算法设计思想实验一采用分治法的思想,最最左和最右两个节点A、B,分别找到离两个节点所在直线两边找距离最远的两个点C、D,再递归下去直到算法结束实验二正整数序列遍历,找到第一个a[j]>a[j+1],删去a[j],重复s次,也就是删去s个数(3)程序设计实验一/*** 快包问题** @author陈雪桂**/public class QuickPackage{static List<Dian> pack = new ArrayList<Dian>();public static void main(String[] args){List<Dian> list = new ArrayList<Dian>();list.add(new Dian(2.3, 12.2));list.add(new Dian(3.6, 29.0));list.add(new Dian(15.4, 2.4));list.add(new Dian(18.4, 34.2));list.add(new Dian(14.2, 15.5));list.add(new Dian(17.1, 37.9));list.add(new Dian(23.1, 18.2));list.add(new Dian(14.2, 34.1));list.add(new Dian(30.2, 45.8));list.add(new Dian(38.6, 22.4));list.add(new Dian(48.6, 32.4));list.add(new Dian(18.6, 22.4));list.add(new Dian(78.6, 62.4));list.add(new Dian(23.3, 39.0));list.add(new Dian(13.9, 43.0));list.add(new Dian(133.3, 234.0));Dian leftDian = list.get(0);Dian rightDian = list.get(0);for (Dian dian : list){if (dian.getX() < leftDian.getX())leftDian = dian;else if (dian.getX() > rightDian.getX())rightDian = dian;}pack.add(leftDian);pack.add(rightDian);QuickPackage p = new QuickPackage();Dian[] dians = new Dian[list.size()];list.toArray(dians);System.out.println(leftDian.getX() + ":"+ leftDian.getY());System.out.println(rightDian.getX() + ":"+ rightDian.getY());Map<String, Dian[]> map = p.separate(dians, leftDian, rightDian);Dian[] left = map.get("left");Dian[] right = map.get("right");p.package1(left, leftDian, rightDian);p.package1(right, rightDian, leftDian);for (Dian dian : pack){System.out.println("X: " + dian.getX() + " " + "Y: " + dian.getY());}}// 核心函数public void package1(Dian[] dians, Dian dian1, Dian dian2) {if (dians.length == 2)return;if (dians.length == 3){for (Dian dian : dians){if (!dian.equals(dian1) && !dian.equals(dian2)){pack.add(dian);}}return;}Dian maxDian = this.maxlength(dians, dian1, dian2);pack.add(maxDian);Map<String, Dian[]> map1 = this.separate(dians, dian1, maxDian);Dian[] right = map1.get("right");Map<String, Dian[]> map2 = this.separate(right, maxDian, dian2);this.package1(map1.get("left"), dian1, maxDian);this.package1(map2.get("left"), maxDian, dian2);}/*** 将点分为在直线左和在直线右边** @param dians* @param dian1* @param dian2* @return*/public Map<String, Dian[]> separate(Dian[] dians, Dian dian1, Dian dian2){List<Dian> left = new ArrayList<>();List<Dian> right = new ArrayList<>();for (Dian dian : dians){double r = dian1.getX() * dian2.getY() + dian.getX() * dian1.getY()+ dian2.getX() * dian.getY() - dian.getX() * dian2.getY()- dian2.getX() * dian1.getY() - dian1.getX() * dian.getY();if (r > 1E-8)left.add(dian);else if (r < 1E-8 && r > -1E-8){left.add(dian);right.add(dian);} elseright.add(dian);}Dian[] leftDians = new Dian[left.size()];Dian[] rightDians = new Dian[right.size()];left.toArray(leftDians);right.toArray(rightDians);left = null;right = null;Map<String, Dian[]> map = new TreeMap<String, Dian[]>();map.put("left", leftDians);map.put("right", rightDians);return map;}/*** 点集合中的点到dian1 、 dian2直线的距离** @param dians* @param dian1* @param dian2* @return*/public Dian maxlength(Dian[] dians, Dian dian1, Dian dian2) {double A = (dian2.getY() - dian1.getY())/ (dian2.getX() - dian1.getX());double B = -1;double C = dian2.getY()- ((dian2.getY() - dian1.getY()) / (dian2.getX() - dian1.getX()))* dian2.getX();double maxlength = 0;Dian maxDian = null;for (Dian dian : dians){if (lengthToLine(dian, A, B, C) > maxlength){maxlength = lengthToLine(dian, A, B, C);maxDian = dian;}}return maxDian;}/*** 点到直线的距离** @param dian* @param A* @param B* @param C* @return*/public double lengthToLine(Dian dian, double A, double B, double C){double i = ((A * dian.getX() + B * dian.getY() + C) / Math.sqrt(A * A+ B * B));return i > 0 ? i : -i;}}class Dian{double x;double y;public Dian(){}public Dian(double x, double y){this.x = x;this.y = y;}public double getX(){return x;}public void setX(double x){this.x = x;}public double getY(){return y;}public void setY(double y){this.y = y;}}实验二/*** 通过键盘输入一个高精度的正整数n(n的有效位数≤240),去掉其中任意s个数字后,剩下的数字按原左右次序将组成一个新的正整数。

内部排序实验报告

内部排序实验报告
//所在位置,此时在它之前(后)的记录均不大(小)于它。算法 10.6(b)
KeyType pivotkey; L.r[0]=L.r[low]; pivotkey=L.r[low].key;
//用子表的第一个记录作枢轴记录 //枢轴记录关键字
while(low< high) {
//从表的两端交替地向中间扫描
h.r[i+1]=d[i]; h.length=N; printf("\n 堆排序前:\n"); print_H(h); HeapSort(h); printf("堆排序后:\n"); print_H(h); goto s123;
case 4: for(i=0;i<N;i++) LL.r[i+1]=d[i]; LL.length=N; printf("归并排序前:\n"); print(LL); MergeSort(LL); printf("归并排序后:\n"); print(LL); goto s123;
RedType d[N]={{20,6},{52,1},{65,3},{88,9},{47,8},{22,4},{39,5},{74,7}}; int i; SqList LL; int dt[T]={5,3,1}; // 增量序列数组 int choice;
s123: cout<<"请选择要使用的排序算法:\n0..............退出\n"; cout<<"1..............插入排序\n2..............交换排序\n"; cout<<"3..............选择排序\n4..............归并排序\n"; cin>>choice; switch(choice) { case 0: break;

数据结构内部算法排序实验程序与结果分析

数据结构内部算法排序实验程序与结果分析

内部算法排序实验比较算法的原理及程序实现:#define CPP C++#define MPP M++#define MP2 M+=2#define MP3 M+=3#include <fstream.h>#include <iomanip.h>#include <stdlib.h>#include <time.h>#include <math.h>const int maxsize=100000; //排序表容量typedef int datatype;typedef struct {datatype key; //关键字域//othertype other; //其它域} rectype; //记录类型typedef rectype list[maxsize+2]; //排序表类型,0号单元不用__int64 C,M; //比较和移动次数void check(list R,int n) { //检验排序结果int i;for(i=2;i<=n;i++)if(R[i].key<R[i-1].key) {cout<<"Error!\n";return;}cout<<"Correct! ";}void disp(list R,int n) { //显示排序后的结果int i;for(i=1;i<=n;i++) {cout<<setw(4)<<R[i].key;// if(i%20==0) cout<<endl;}cout<<endl;}//直接插入部分/*无序区第一记录R[i] 插入有序区R[1]~R[i-1],找插入位置和移动记录交替进行:从有序区的后部j开始,如果该位置记录大于待插记录,则后移一位;待插记录插入到最后空出的位置上*/void InsertSort1(list R,int n) {//直接插入排序,带监视哨(并不改变关键字次数)int i,j;for(i=2;i<=n;i++) { //依次插入R[2],R[3],…,R[n]if(CPP,R[i].key>=R[i-1].key) continue;//R[i]大于有序区最后一个记录,则本趟不需插入MPP,R[0]=R[i]; //R[0]是监视哨j=i-1;do { //查找R[i]的插入位置MPP,R[j+1]=R[j];j--; //记录后移,继续向前搜索} while(CPP,R[0].key<R[j].key);MPP,R[j+1]=R[0]; //插入R[i]}}void InsertSort2(list R,int n) {//直接插入排序,无监视哨int i,j;rectype x; //x为辅助量(用R[0]代替时间变长)for(i=2;i<=n;i++) { //进行n-1次插入if(CPP,R[i].key>=R[i-1].key) continue;MPP,x=R[i]; //待排记录暂存到xj=i-1;do { //顺序比较和移动MPP,R[j+1]=R[j];j--;} while(j>=1 && (CPP,x.key<R[j].key));MPP,R[j+1]=x; //插入R[i]}}//折半插入排序void BInsertSort(rectype *R,long n){long i,j,low,m,high;for(i=2;i<=n;i++){R[0].key=R[i].key; //R[i].key暂存到R[0].keylow=1;high=i-1;while(low<=high) { //在R[low....heigh]中折半查找有序插入位置m=(low+high)/2; //折半*/if(CPP,R[0].key<R[m].key) high=m-1; //插入点在低半区else low=m+1; //插入点在高半区}for(j=i-1;j>=high+1;j--) //记录后移CPP,R[j+1].key=R[j].key;R[high+1].key=R[0].key; //插入}}//希尔排序部分/* 希尔排序又称缩小增量排序,是1959年由D.L.Shell提出来的,其中运用的直接插入排序算法简单,在n值较小时,效率比较高,在n值很大时,若序列按关键码基本有序,效率依然较高。

内部排序实验报告

内部排序实验报告

内部排序实验报告内部排序实验报告一、引言内部排序是计算机科学中的重要概念,它指的是对一个数据集合进行排序的过程。

在计算机科学中,排序算法是一种基本的算法,它对于提高数据处理效率和优化算法性能有着重要的作用。

本实验旨在通过实际操作和对比分析,探究不同内部排序算法的性能差异。

二、实验目的1. 了解内部排序的基本概念和常用算法;2. 掌握不同内部排序算法的实现方法;3. 比较不同内部排序算法的时间复杂度和空间复杂度;4. 分析实验结果,总结不同算法的优缺点。

三、实验过程1. 实验环境搭建在进行实验之前,我们需要搭建适当的实验环境。

选择一种编程语言,并准备好相应的开发环境。

2. 实验数据准备为了进行排序算法的测试,我们需要准备一组测试数据。

可以选择不同规模的数据集,包括有序、无序和部分有序等情况。

3. 实验算法实现选择几种常用的内部排序算法,如冒泡排序、插入排序、选择排序、快速排序和归并排序等。

分别实现这些算法,并确保其正确性。

4. 实验性能测试使用不同规模的测试数据对算法进行性能测试。

记录每个算法的运行时间和所占用的内存空间。

5. 实验结果分析根据实验数据和测试结果,对比分析不同算法的性能差异。

针对时间复杂度和空间复杂度,给出相应的分析和解释。

四、实验结果与分析经过实验测试,我们得到了不同内部排序算法的运行时间和内存占用情况。

下面对实验结果进行分析和解释。

1. 时间复杂度分析通过实验数据,我们可以观察到不同算法的运行时间随着数据规模的增加而增加。

快速排序和归并排序在大规模数据集上表现出色,时间复杂度为O(nlogn)。

而冒泡排序和选择排序的时间复杂度为O(n^2),在大规模数据集上性能较差。

2. 空间复杂度分析在内部排序中,空间复杂度是指算法执行过程中所需的额外内存空间。

插入排序和冒泡排序是原地排序算法,它们的空间复杂度为O(1)。

而归并排序和快速排序需要额外的空间来存储中间结果,空间复杂度为O(n)。

数据结构(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、为了提高数据的查找速度,需要对数据进行排序。

3、掌握内排序的方法。

二、实验内容1、设计一个程序e xp10—1.cpp实现直接插入排序算法,并输出{9,8,7,6,5,4,3,2,1,0}的排序过程。

(1)源程序如下所示://文件名:exp10-1.cpp#include <stdio.h>#define MAXE 20//线性表中最多元素个数typedef int KeyType;typedef char InfoType[10];typedef struct //记录类型{KeyType key; //关键字项InfoType data; //其他数据项,类型为InfoType} RecType;void InsertSort(RecType R[],int n) //对R[0..n-1]按递增有序进行直接插入排序{int i,j,k;RecType temp;for (i=1;i<n;i++){temp=R[i];j=i-1; //从右向左在有序区R[0..i-1]中找R[i]的插入位置while (j>=0 && temp.key<R[j].key){R[j+1]=R[j];//将关键字大于R[i].key的记录后移j--;}R[j+1]=temp;//在j+1处插入R[i]printf("i=%d,",i);//输出每一趟的排序结果printf("插入%d,结果为: ",temp);for (k=0;k<n;k++)printf("%3d",R[k].key);printf("\n");}}void main(){int i,k,n=10;KeyType a[]={9,8,7,6,5,4,3,2,1,0};RecType R[MAXE];for (i=0;i<n;i++)R[i].key=a[i];printf("初始关键字: ");//输出初始关键字序列for (k=0;k<n;k++)printf("%3d",R[k].key);printf("\n");InsertSort(R,n);printf("最后结果: ");//输出初始关键字序列for (k=0;k<n;k++)printf("%3d",R[k].key);printf("\n");}(2)运行的结果如下图所示:2、设计一个程序exp10—2.cpp实现希尔插入排序算法,并输出{9,8,7,6,5,4,3,2,1,0}的排序过程。

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

广东工业大学实验报告______________学院________________专业_____班成绩评定_______实验题目:数据结构(内部排序算法)第一章实验需求分析与方案排序算法对于计算机信息处理很重要,一个好的排序不仅可以使信息查找的效率提高,而且还直接影响着计算机的工作效率。

目前,最常见的排序算法有冒泡排序法、选择排序法、插入排序法、快速排序法等算法。

这些排序算法各有自己的优缺点,不同的排序算法适应不同的情况。

就算法的整体性能而言,目前很难提出一种适应所有的排序场合的最好的排序算法,每种算法都有自己不同的适用场合。

使用插入排序法,交换排序法,选择排序法设计与实现算法程序完成线性表的排序号。

通过测试分析说明各排序算法的优缺点。

通过实验结果分析,总结插入排序法,交换排序法,选择排序法三类算法的特点。

第二章实验过程与结果a)直接插入法算法算法实现程序:主程序://直接插入排序算法#include <stdio.h>//待排记录数据类型#define MAXSIZE 30 //一个用作示例的小顺序表的最大长度typedef int KeyType; //定义关键字类型为整数类型typedef struct{KeyType key; //关键字项//InfoType otherinfo; //其他数据项}RedType; //记录类型typedef struct{RedType r[MAXSIZE+1]; //r[0]闲置或用作哨兵单元int length; //顺序表长度}SqList;int c;//比较次数comparetimeint m;//移动次数movetime//Output内部排序算法输出函数void Output(SqList &L){for(int i=1;i<=L.length;i++){printf(" %d ",L.r[i].key);}printf("\n");}//InsertionSort直接插入排序算法void InsertionSort(SqList &L){//对顺序表L作直接插入排序。

int c=0;//比较次数comparetimeint m=0;//移动次数movetimefor (int i=2;i<=L.length;++i){if(L.r[i].key < L.r[i-1].key){ //"<",需将L.r[i]插入有序表L.r[0] = L.r[i]; //复制哨兵m++;L.r[i] = L.r[i-1];m++;for (int j=i-2; L.r[0].key < L.r[j].key; --j,c++ )L.r[j+1].key = L.r[j].key; //记录后移m++;L.r[j+1] = L.r[0]; //插入到正确位置m++;}c++;m++;Output(L);}printf("\t移动次数m:%d\n",m);printf("\t比较次数c:%d\n",c);}//InsertionSortvoid main(){printf("\t\t InserionSort直接插入排序算法\n");printf("\n");printf("\t\t 待排序顺序表L: 59 48 75 107 86 23 37 59 55 20\n");printf("\n");SqList L;L.r[1].key=59; L.r[2].key=48;L.r[3].key=75; L.r[4].key=107;L.r[5].key=86; L.r[6].key=23;L.r[7].key=37; L.r[8].key=59;L.r[9].key=55; L.r[10].key=20;L.length=10;printf("\n");printf("对顺序表L进行排序:");printf("\n");InsertionSort(L);printf("\n");printf("\t输出InsertionSort结果:\n");Output(L);printf("\n");}运行结果●排序过程比较和移动次数。

插入排序算法具体操作为:将待排序数组分为两部分,第一部分包括这个数组中除最后一个元素外的所有元素,第二部分为最后一个元素,直到第一部分排好序后,再将第二部分插入到已排好序的第一部分中,如此递归,最终为第一部分为数组第一个元素,第二部分为数组第二个元素,二者排序完毕后继续将后面的元素插入,如此直至数组最后一个元素插入完毕,整个数组排序完毕。

排序过程中,数据的移动次数为37,比较次数为31。

b)折半插入法算法●算法实现程序;主程序://折半插入排序算法#include <stdio.h>//待排记录数据类型#define MAXSIZE 30 //一个用作示例的小顺序表的最大长度typedef int KeyType; //定义关键字类型为整数类型typedef struct{KeyType key; //关键字项//InfoType otherinfo; //其他数据项}RedType; //记录类型typedef struct{RedType r[MAXSIZE+1]; //r[0]闲置或用作哨兵单元int length; //顺序表长度}SqList;int c;//比较次数comparetimeint m;//移动次数movetime//Output内部排序算法输出函数void Output(SqList &L){for(int i=1;i<=L.length;i++){printf(" %d ",L.r[i].key);}printf("\n");}//BinaryInsertionSort折半插入排序算法void BinaryInsertionSort (SqList &L){//对顺序表L作折半插入排序。

int c=0;//比较次数comparetimeint m=0;//移动次数movetimefor (int i=2;i<=L.length; ++i,c++){L.r[0] = L.r[i]; //将L.r[i]暂存到L.r[0]int low = 1;int high = i-1;while (low <= high) { //在r[loe..high]中折半查找有序插入的位置int mid = (low+high)/2; //折半if (L.r[0].key<L.r[mid].key) high = mid-1;//插入点在低半区else low = mid+1;//插入点在高半区m++;}//whileOutput(L);for ( int j = i-1;j >= high+1; --j,c++) L.r[j+1] = L.r[j];//记录后移m++;L.r[high+1] = L.r[0]; //插入m++;Output(L);}//forprintf("\t移动次数m:%d\n",m);printf("\t比较次数c:%d\n",c);}//BinaryInsertionSortvoid main(){printf("\t\t BinaryInsertionSort折半插入排序算法\n");printf("\n");printf("\t\t 待排序顺序表L: 59 48 75 107 86 23 37 59 55 20\n");printf("\n");SqList L;L.r[1].key=59; L.r[2].key=48;L.r[3].key=75; L.r[4].key=107;L.r[5].key=86; L.r[6].key=23;L.r[7].key=37; L.r[8].key=59;L.r[9].key=55; L.r[10].key=20;L.length=10;printf("\n");printf("对顺序表L进行排序:");printf("\n");BinaryInsertionSort(L);printf("\n");printf("\t输出BinaryInsertionSort结果:\n");Output(L);printf("\n");}运行结果●排序过程比较和移动次数。

折半插入排序算法的具体操作为:在将一个新元素插入已排好序的数组的过程中,寻找插入点时,将待插入区域的首元素设置为a[low],末元素设置为a[high],则轮比较时将待插入元素与a[m],其中m=(low+high)/2相比较,如果比参考元素小,则选择a[low]到a[m-1]为新的插入区域(即high=m-1),否则选择a[m+1]到a[high]为新的插入区域(即low=m+1),如此直至low<=high不成立,即将此位置之后所有元素后移一位,并将新元素插入a[high+1]。

排序过程中,数据的移动次数为40,比较次数为38。

c)希尔排序算法●算法实现程序主程序://希尔排序算法#include <stdio.h>//待排记录数据类型#define MAXSIZE 30 //一个用作示例的小顺序表的最大长度typedef int KeyType; //定义关键字类型为整数类型typedef struct{KeyType key; //关键字项//InfoType otherinfo; //其他数据项}RedType; //记录类型typedef struct{RedType r[MAXSIZE+1]; //r[0]闲置或用作哨兵单元int length; //顺序表长度}SqList;int c;//比较次数comparetimeint m;//移动次数movetime//Output内部排序算法输出函数void Output(SqList &L){for(int i=1;i<=L.length;i++){printf(" %d ",L.r[i].key);}printf("\n");}//Shell's Sort希尔排序算法void ShellInsert(SqList &L, int dk){//对顺序表L作一趟希尔插入排序。

相关文档
最新文档