数据结构实验报告内排序
数据结构与算法实验报告及代码-内排序

实验五内排序1.实验目的(1)掌握在数组上进行各种排序的方法和算法(2)加深对排序的理解,逐步培养解决实际问题的编程能力2.实验内容(1)完成直接插入排序算法(2)完成起泡(冒泡)排序算法3.实验重点熟悉和掌握数组上各种排序方法和算法4. 实验难点掌握数组上各种排序方法和算法5.实验指导参考程序代码如下:(1)/*****************************************//* 直接插入排序算法 *//*****************************************/InsertSort.hvoid InsertSort (DataType a[], int n)//用直接插入法对a[0]--a[n-1]排序{int i, j;DataType temp;for(i=0; i<n-1; i++){temp = a[i+1];j = i;while(j > -1 && temp.key < a[j].key){a[j+1] = a[j];j--;}a[j+1] = temp;}}InsertSort.cpp#include <iostream>using namespace std;typedef int KeyType;struct DataType{KeyType key;};#include "InsertSort.h"void main(void){DataType test[6]={64,5,7,89,6,24};int n = 6;InsertSort(test,n);for(int i=0; i<n; i++)cout << test[i].key << " "; system("pause");}/*****************************************/ /* 冒泡排序算法 */ /*****************************************/ datatype.htypedef int keytype;struct datatype{keytype key;};BubbleSort.cpp#include <iostream>using namespace std;#include"datatype.h"void BubbleSort(datatype a[], int n)//用冒泡排序法对a[0]--a[n-1]排序{int i, j, flag=1;datatype temp;for(i = 1; i < n && flag == 1; i++){flag = 0;for(j = 0; j < n-i; j++){if(a[j].key > a[j+1].key){flag = 1;temp = a[j];a[j] = a[j+1];a[j+1] = temp;}}}}void main(void){datatype test[6]={64,5,7,89,6,24};int n = 6;BubbleSort(test,n);for(int i=0; i<n; i++)cout << test[i].key << " "; system("pause");}。
(完整)数据结构(C语言版)实验报告 (内部排序算法比较)

(完整)数据结构(C语言版)实验报告 (内部排序算法比较)编辑整理:尊敬的读者朋友们:这里是精品文档编辑中心,本文档内容是由我和我的同事精心编辑整理后发布的,发布之前我们对文中内容进行仔细校对,但是难免会有疏漏的地方,但是任然希望((完整)数据结构(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]。
数据结构实验报告-排序

数据结构实验报告-排序一、实验目的本实验旨在探究不同的排序算法在处理大数据量时的效率和性能表现,并对比它们的优缺点。
二、实验内容本次实验共选择了三种常见的排序算法:冒泡排序、快速排序和归并排序。
三个算法将在同一组随机生成的数据集上进行排序,并记录其性能指标,包括排序时间和所占用的内存空间。
三、实验步骤1. 数据的生成在实验开始前,首先生成一组随机数据作为排序的输入。
定义一个具有大数据量的数组,并随机生成一组在指定范围内的整数,用于后续排序算法的比较。
2. 冒泡排序冒泡排序是一种简单直观的排序算法。
其基本思想是从待排序的数据序列中逐个比较相邻元素的大小,并依次交换,从而将最大(或最小)的元素冒泡到序列的末尾。
重复该过程直到所有数据排序完成。
3. 快速排序快速排序是一种分治策略的排序算法,效率较高。
它将待排序的序列划分成两个子序列,其中一个子序列的所有元素都小于等于另一个子序列的所有元素。
然后对两个子序列分别递归地进行快速排序。
4. 归并排序归并排序是一种稳定的排序算法,使用分治策略将序列拆分成较小的子序列,然后递归地对子序列进行排序,最后再将子序列合并成有序的输出序列。
归并排序相对于其他算法的优势在于其稳定性和对大数据量的高效处理。
四、实验结果经过多次实验,我们得到了以下结果:1. 冒泡排序在数据量较小时,冒泡排序表现良好,但随着数据规模的增大,其性能明显下降。
排序时间随数据量的增长呈平方级别增加。
2. 快速排序相比冒泡排序,快速排序在大数据量下的表现更佳。
它的排序时间线性增长,且具有较低的内存占用。
3. 归并排序归并排序在各种数据规模下都有较好的表现。
它的排序时间与数据量呈对数级别增长,且对内存的使用相对较高。
五、实验分析根据实验结果,我们可以得出以下结论:1. 冒泡排序适用于数据较小的排序任务,但面对大数据量时表现较差,不推荐用于处理大规模数据。
2. 快速排序是一种高效的排序算法,适用于各种数据规模。
数据结构实验四报告排序

数据结构实验报告实验名称:实验四——排序学生姓名:班级:班内序号:学号:日期: 2013年12月16日1.实验要求使用简单数组实现下面各种排序算法,并进行比较。
排序算法:1、插入排序2、希尔排序3、冒泡排序4、快速排序5、简单选择排序6、堆排序(选作)7、归并排序(选作)8、基数排序(选作)9、其他要求:1、测试数据分成三类:正序、逆序、随机数据2、对于这三类数据,比较上述排序算法中关键字的比较次数和移动次数(其中关键字交换计为3次移动)。
3、对于这三类数据,比较上述排序算法中不同算法的执行时间,精确到微秒(选作)4、对2和3的结果进行分析,验证上述各种算法的时间复杂度编写测试main()函数测试线性表的正确性。
2. 程序分析2.1 存储结构使用最简单的一维数组存储待排序的数据。
共使用三个数组,一个用来构造正序数组,一个是逆序数组,还有一个是随机数组。
每种排序使用的数组都是具有相同初始值的,因而使得试验结果具有可比较性。
2.2关键算法分析2.2.1 插入排序算法插入排序的思想是:每次从无序区取一元素将其添加到有序区中。
2.2.2希尔排序算法希尔排序是一种缩小增量排序的算法,首先将待排序元素集按照一定间隔分成多个子集,分别对这些子集进行直接插入排序,整个序列部分有序。
然后缩小间隔,在进行直接插入排序,直到间隔为1,此时,整个序列已全部有序。
2.2.3起泡排序起泡排序的思想是:两两比较相邻的元素,如果反序,则交换次序,直到没有反序的元素为止。
在此思想指导下①首先将待排序元素划分为有序区和无序区,初始状态有序区为空,无序区所有待排序素;②对无序区从前向后依次将相邻元素关键码进行比较,若反序,则交换③重复执行②直到无序区中没有元素。
2.2.4快速排序算法2,2,4,1一趟快速排序算法自然语言描述如下①选取区间第一个元素作为轴值②读取区间首尾坐标,并将其左右侧待比较元素③右侧扫描:从后向前找到第一个比轴值小的元素,和左侧待比较元素交换(左侧第一个带比较元素为轴值)④左侧扫描:从前向后找到第一个比轴值大的元素,和右侧待比较元素交换⑤重复②③,直到左右两侧带比较元素的坐标相等其c++描述如下2.2.4.2完整的快速排序算法如下:选择排序自然语言描述如下:①在r[1]~r[n]待排序元素序列中选出最小记录,将其与第一个元素r[n]交换②在r[2]~r[n]待排序元素序列中选出最小记录,将其与第一个元素r[i]交换…………③直至r[n-1]~r[n]C++描述如下:2.2.6堆排序2.2.6.1堆的建立,按照小根堆的定义建立堆的算法如下说明:根节点存放在r[1]中,r[i]的左孩子为r[2*i],右孩子为r[2*i+1]2.2.6.2调整数组为升序排列①输出堆顶元素②将堆中最后一个元素移至堆顶,并将剩余元素调整为小根堆③反复执行①②两个元素,直到堆中只有一个元素2.2.6.2堆排序完整算法如下3. 程序运行结果测试主函数运行流程图:开始初始化数组,计数器排序,输出比较次数和移动次数结束源代码#include<iostream>#include"time.h"using namespace std;void InsertSort(int r[], int n)//直接插入排序{int count1 = 0, count2 = 0;//分别用来记录插入排序比较和移动次数的计数器for (int i = 2; i <= n - 1; i++){if (r[i]<r[i - 1])//查找插入位置{r[0] = r[i]; //设置哨兵count2++; //移动次数加1int j;for (j = i - 1; count1++, r[0]<r[j]; j--) //寻找插入位置{r[j + 1] = r[j]; //元素后移count2++; //移动次数加1}r[j + 1] = r[0];//插入记录count2++;}else count1++;//此时虽然没有移动但是已经进行了一次比较}cout << "比较" << count1 << "移动" << count2;}void ShellSort(int r[], int n) //希尔排序{int i, d, j;int count1 = 0, count2 = 0;for (d = n / 2; d >= 1; d = d / 2) //以增量为d进行直接插入排序{for (i = d + 1; i<n; i++) //一趟希尔排序{r[0] = r[i]; //暂存被插入记录for (j = i - d; j>0 && r[0]<r[j]; j = j - d)//每隔d个记录进行一次比较和移动r[j + d] = r[j]; //记录后移d个位置r[j + d] = r[0];count1++;count2 = count2 + d;//每次都移动d个位置}count1++;}cout << "比较" << count1 << "移动" << count2;}void BubbleSort(int r[], int n) //起泡排序{int temp, pos, bound;int count1 = 0, count2 = 0;pos = n - 1; //第一趟起泡排序的范围是r[1]到r[n]while (pos != 0) //仅当上一趟排序有记录交换才进行本趟排序{bound = pos; //本次无序元素的范围pos = 0; //控制外循环结束for (int j = 1; j<bound; j++) //一趟起泡排序{count1++; //接下来有一次比较if (r[j]>r[j + 1]) //相邻元素比较{temp = r[j]; //交换r[j]和r[j+1]r[j] = r[j + 1];r[j + 1] = temp;pos = j; //记录每一次发生记录交换的位置当j=0时说明一次比较也没有了即已经全部有序了count2 = count2 + 3; //一个交换语句为一次移动共移动了次}}}cout << "比较" << count1 << "移动" << count2;}int Partition(int r[], int first, int end, int &count1, int &count2)//快速排序一次划分{int i = first; //初始化int j = end;int temp;while (i<j){while (i<j && r[i] <= r[j]){j--; //右侧扫描count1++;}if (i<j){temp = r[i];r[i] = r[j]; //将较小记录交换到前面r[j] = temp;i++;count2 = count2 + 3;count1++;}while (i<j && r[i] <= r[j]){i++; //左侧扫描count1++;}if (i<j){temp = r[i];r[i] = r[j]; //将较小记录交换到前面r[j] = temp; //将较大记录交换到后面j--;count2 = count2 + 3;count1++;}}return i; //i为轴值记录的最终位置}void QuickSort(int r[], int first, int end, int &count1, int &count2)//快速排序{if (first<end){ //递归结束,继续执行下边的操作int pivot = Partition(r, first, end, count1, count2); //一次划分QuickSort(r, first, pivot - 1, count1, count2);//递归地对左侧子序列进行快速排序QuickSort(r, pivot + 1, end, count1, count2); //递归地对右侧子序列进行快速排序}}void SelectSort(int r[], int n)//简单选择排序{int i;int j;int index; //初始化int temp;int count1 = 0, count2 = 0;for (i = 1; i<n; i++) //对n个记录进行n-1趟简单选择排序{index = i; //假设index是最小的for (j = i + 1; j<n; j++) //在无序区中选取最小记录{if (r[j]<r[index]) //如果该元素比现在第i个位置的元素小index = j;//赋值给indexcount1++; //比较次数加一}//count1++; //在判断不满足循环条件j<n时比较了一次if (index != i){temp = r[i]; //将无序区的最小记录与第i个位置上的记录交换r[i] = r[index];r[index] = temp;count2 = count2 + 3; //移动次数加}}cout << "比较" << count1 << "移动" << count2;}void Sift(int r[], int k, int m, int &count1, int &count2)//小根堆筛选算法筛选法调整堆,s t分别为比较和移动次数,m为编号最大的叶子结点的编号{int i = k;int j = 2 * i + 1; //置i为要筛的结点j为i的左孩子int temp;while (j <= m) //筛选还没有进行到叶子{if (j<m && r[j]<r[j + 1])j++; //比较i的左右孩子j为较大者count1 = count1 + 2; //该语句之前和之后分别有一次比较if (r[i]>r[j])break; //根结点已经大于左右孩子中的较大者则结束循环else{temp = r[i];r[i] = r[j];r[j] = temp; //将根结点与结点j交换i = j;j = 2 * i + 1; //下一个被筛结点位于原来结点j的位置count2 = count2 + 3; //移动次数加}}}void HeapSort(int r[], int n)//堆排序{int count1 = 0, count2 = 0; //计数器计比较和移动次数int i;int temp;for (i = n / 2; i >= 0; i--) //初始建堆从下向上(从最后一个分支结点开始)的过程(整体)Sift(r, i, n, count1, count2);for (i = n - 1; i>0; i--) //重复执行移走堆顶及重建堆的操作{temp = r[i]; //将堆顶元素与将堆顶记录和当前未经排序子序列r[1..i]中最后一个记录相互交换r[i] = r[0];r[0] = temp; //完成一趟排序输出记录的次序状态Sift(r, 0, i - 1, count1, count2); //重建堆}cout << "比较" << count1 << "移动" << count2;}void Newarray(int a[], int b[])//产生顺序、逆序及随机数组{a[0] = 0;b[0] = 0;for (int s = 1; s<501; s++){a[s] = s; //顺序数组b[s] = 501 - s; //逆序数组}}void main(){srand(time(NULL));int c[501];c[0] = 0;cout << "随机数组: ";for (int s = 1; s < 501; s++){c[s] = rand() % 50 + 1;cout << c[s]<<" ";}const int num = 501; //赋值最大的数组的容量int a[num];int b[num];int c1[num];a[0] = 0;b[0] = 0;Newarray(a, b);cout << "顺序数组:";for (int j = 1; j<num; j++)cout << a[j] << " ";cout << endl;cout << "逆序数组:";for (int j = 1; j<num; j++)cout << b[j] << " ";cout << endl;cout << endl;cout << "排序方式" << " " << "正序" << " " << "逆序" << " " << "随机"<<endl<<endl;cout << "直接插入排序" << " ";Newarray(a, b);int count1 = 0, count2 = 0;InsertSort(a, num);cout << " ";InsertSort(b, num);cout << " ";InsertSort(c, num);count1 = 0, count2 = 0;cout << endl<<endl;cout << "希尔排序" << " ";Newarray(a, b);ShellSort(a, num);cout << " ";ShellSort(b, num);cout << " ";ShellSort(c, num);count1 = 0, count2 = 0;cout << endl<<endl;cout << "起泡排序" << " ";Newarray(a, b);BubbleSort(a, num);cout << " ";BubbleSort(b, num);cout << " ";BubbleSort(c, num);count1 = 0, count2 = 0;cout << endl<<endl;cout << "快速排序" << " ";Newarray(a, b);QuickSort(a, 0, num - 2, count1, count2);cout << "比较" << count1 << "移动" << count2 << " ";count1 = 0, count2 = 0;QuickSort(b, 0, num - 2, count1, count2);cout << "比较" << count1 << "移动" << count2 << " ";count1 = 0, count2 = 0;QuickSort(c, 0, num - 1, count1, count2);cout << "比较" << count1 << "移动" << count2 << endl<<endl;count1 = 0, count2 = 0;Newarray(a, b);cout << "简单选择排序"<<" ";SelectSort(a, num);cout << " ";SelectSort(b, num);cout << " ";SelectSort(c, num);cout << endl<<endl;Newarray(a, b);count1 = 0, count2 = 0;cout << "堆排序"<<" ";HeapSort(a, num);cout << " ";HeapSort(b, num);cout << " ";HeapSort(c, num);cout << endl;cout << "程序结束!";}。
《数据结构》实验报告——排序

《数据结构》实验报告排序实验题目:输入十个数,从插入排序,快速排序,选择排序三类算法中各选一种编程实现。
实验所使用的数据结构内容及编程思路:1.插入排序:直接插入排序的基本操作是,将一个记录到已排好序的有序表中,从而得到一个新的,记录增一得有序表。
一般情况下,第i趟直接插入排序的操作为:在含有i-1个记录的有序子序列r[1..i-1]中插入一个记录r[i]后,变成含有i个记录的有序子序列r[1..i];并且,和顺序查找类似,为了在查找插入位置的过程中避免数组下标出界,在r[0]处设置哨兵。
在自i-1起往前搜索的过程中,可以同时后移记录。
整个排序过程为进行n-1趟插入,即:先将序列中的第一个记录看成是一个有序的子序列,然后从第2个记录起逐个进行插入,直至整个序列变成按关键字非递减有序序列为止。
2.快速排序:基本思想是,通过一趟排序将待排记录分割成独立的两部分,其中一部分记录的关键字均比另一部分记录的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序。
假设待排序的序列为{L.r[s],L.r[s+1],…L.r[t]},首先任意选取一个记录(通常可选第一个记录L.r[s])作为枢轴(或支点)(pivot),然后按下述原则重新排列其余记录:将所有关键字较它小的记录都安置在它的位置之前,将所有关键字较大的记录都安置在它的位置之后。
由此可以该“枢轴”记录最后所罗的位置i作为界线,将序列{L.r[s],…,L.r[t]}分割成两个子序列{L.r[i+1],L.[i+2],…,L.r[t]}。
这个过程称为一趟快速排序,或一次划分。
一趟快速排序的具体做法是:附设两个指针low和high,他们的初值分别为low和high,设枢轴记录的关键字为pivotkey,则首先从high所指位置起向前搜索找到第一个关键字小于pivotkey的记录和枢轴记录互相交换,然后从low所指位置起向后搜索,找到第一个关键字大于pivotkey的记录和枢轴记录互相交换,重复这两不直至low=high为止。
《数据结构》排序+实验报告格式

河南工业大学实验报告课程数据结构 _ 实验名称实验六:内部排序院系_国际高等技术学院__ 专业班级__ 国计1005班_____ 实验地点 513-2机房姓名____王普花__ 学号__201038940532 实验时间 12月6日指导老师王云侠实验成绩批改日期一.实验目的1.熟悉相关的排序算法二.实验内容及要求1.实现两种排序算法三.实验过程及结果#include <malloc.h>#include<stdio.h>#define N 11/*冒泡排序法*/void mpsort(int array[]){int i,j,a;a=0;for(i=1;i<N;i++)for(j=i+1;j<N;j++)if(array[i]>array[j]){a=array[i];array[i]=array[j];array[j]=a;}}/*直接插入排序*/void insertsort(int array[]){int i,j;for(i=2;i<N;i++){array[0]=array[i];j=i-1;while(array[0]<array[j]){array[j+1]=array[j--];array[j+1]=array[0];}}}/*建立*/void creat(int array[]){int i;printf("请输入一列数: ");for(i=1;i<N;i++)scanf("%d",&array[i]);}/*显示*/void print(int array[]){int i;printf("排序后的结果是: ");for(i=1;i<N;i++)printf("%d ",array[i]);printf("\n");}main(){int a[11],i,x,chang;aga:printf(" 1:冒泡排序法 \n");printf(" 2:直接插入排序法 \n");printf(" 3:退出 \n");printf(" 请选择:");scanf("%d",&chang);switch (chang){case 1:{creat(a);insertsort(a);print(a);goto aga;}case 2:{creat(a);mpsort(a);print(a);goto aga;}case 3:{ printf("exit! \n");break;}default:{printf("Error! "); goto aga;} }}排序运行结果如图:四.实验中的问题及心得在设计的过程中遇到问题,可以说是困难重重,同时在设计过程中发现了自己的不足之处,对以前所学过的知识理解的不透彻,掌握的不够牢固,通过这次课程设计之后,一定把以前所学过的知识重新温故一下。
数据结构内排序实验报告

一、实验目的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}的排序过程。
数据结构与算法实验报告_内排序

数据结构与算法实验报告实验名称:二分插入排序及其性能姓名:学号:专业:指导教师:日期:2012-5-22一、实验目的了解二分插入排序与直接插入排序的关系;掌握二分插入排序算法的实现;掌握算法运行时间的测量。
二、实验内容实现二分插入排序算法,并将它和直接插入排序算法进行性能比较,然后用理论分析支持你的结论。
三、实验环境Window XP操作系统;Microsoft VisualC++编程环境;Pentium(R) Dual-Core cpu;2.50GHz,2.00GB内存四、实现1.类间的关系提示:总排序类、插入排序类、直接插入排序类、二分插入排序类间的关系答:父类是:总排序类子类是:插入排序类和二分插入排序类父类是:插入排序类子类是:直接插入排序类2.二分插入排序类排序函数sort的实现结果:3.性能测试程序的主要代码//二分法插入排序,Array[]为待排序数组,n为数组长度template <class Record,class Compare>void BinaryInsertSorter<Record,Compare>::Sort(Record Array[], int n) {Record TempRecord; //用来保存当前待插入纪录的临时变量int left,right,middle; //记录已排好序序列的左、右、中位置for (int i=1;i<n;i++) //插入第i个记录{TempRecord = Array[i]; //将当前待插入记录保存在临时变量中left = 0; right = i-1; //记录已排好序序列的左右位置while(left <= right) //开始查找待插入记录的正确位置{middle = (left+right)/2; //记录中间位置//如果待插入记录比中间记录小,就在左一半中查找,否则,在右一半中查找if (Compare::lt(TempRecord, Array[middle]))right = middle-1;else left = middle+1;}//将前面所有大于当前待插入记录的记录后移for(int j = i-1; j >= left; j --)Array[j+1] = Array[j];Array[left] = TempRecord; //将待插入记录回填到正确位置}}五、实验数据及结论1.实验数据及分析实验过程的描述。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验题目:内排序
一、实验目的和任务
1 掌握堆排序、快速排序算法;
2 掌握直接插入排序、简单选择排序、气泡排序算法。
二、实验内容及原理
1给定一组元素,如(46,74,16,53,14,26,40,38,86,65,27,34),写出堆排序、快速排序算法及程序。
2复习之前学过的直接插入排序、简单选择排序、气泡排序,并写出相应的算法及程序。
3 如果此实验要求用外排序完成,参考书中的程序仿写外排序的相关程序。
四、实验数据及程序代码
#include <stdio.h>
#include <iostream.h>
#include <stdlib.h>
struct ElemType {
int num;
int stn;
char bir[12];
};
void Sift(ElemType A[], int n, int i) //堆排序
{
ElemType x = A[i];
int j;
j = 2 * i + 1;
while (j <= n - 1) {
if (j<n - 1 && A[j].stn<A[j + 1].stn)j++;
if (x.stn<A[j].stn)
{
A[i] = A[j]; i = j; j = 2 * i + 1;
}
else break;
}
A[i] = x;
}
void HeapSort(ElemType A[], int n)
{
ElemType x;
int i;
for (i = n / 2 - 1; i >= 0; i--)Sift(A, n, i);
for (i = 1; i <= n - 1; i++)
{
x = A[0]; A[0] = A[n - i]; A[n - i] = x;
Sift(A, n - i, 0);
}
}
void QuickSort(ElemType A[], int s, int t) //快速排序
{
int i = s + 1, j = t;
ElemType x = A[s];
while (i <= j) {
while (A[i].stn <= x.stn && i <= j)i++;
while (A[j].stn >= x.stn && j >= i)j--;
if (i<j)
{
ElemType temp = A[i]; A[i] = A[j]; A[j] = temp;
i++; j--;
}
}
if (s != j) { A[s] = A[j]; A[j] = x; }
if (s<j - 1)QuickSort(A, s, j - 1);
if (j + 1<t)QuickSort(A, j + 1, t);
}
void InsertSort(ElemType A[], int n) //直接插入排序
{
ElemType x;
int i, j;
for (i = 1; i<n; i++)
{
x = A[i];
for (j = i - 1; j >= 0; j--)
if (x.stn<A[j].stn)A[j + 1] = A[j];
else break;
A[j + 1] = x;
}
}
void SelectSort(ElemType A[], int n) //直接选择排序
{
ElemType x;
int i, j, k;
for (i = 1; i <= n - 1; i++)
{
k = i - 1;
for (j = i; j <= n - 1; j++)
{
if (A[j].stn<A[k].stn)k = j;
}
if (k != i - 1)
{
x = A[i - 1]; A[i - 1] = A[k]; A[k] = x;
}
}
}
void BubbleSort(ElemType A[], int n) //冒泡排序
{
ElemType x;
int i, j, flag;
for (i = 1; i <= n - 1; j--)
{
flag = 0;
for (j = n - 1; j >= i; j--)
if (A[j].stn<A[j - 1].stn)
{
x = A[j - 1]; A[j - 1] = A[j]; A[j] = x;
flag = 1;
}
if (flag == 0) return;
}
}
void main()
{
int t[12] = { 46,74,16,53,14,26,40,38,86,65,27,34 };
int i,flag;
ElemType* a = new ElemType[12];
for (i = 0; i<12; i++)
{
cout << t[i] << ' ';
}
cout << endl <<"选择排序方式:"<< endl <<"1.快速"<< endl <<"2.堆排序"<< endl <<"3.直接插入"<< endl <<"4.直接选择"<< endl <<"5.气泡排序"<< endl;
loop:for (i = 0; i<12; i++)
{
a[i].stn = t[i];
}
cin >> flag;
switch (flag)
{
case 2:
HeapSort(a, 12);
cout <<"堆排序结果"<< endl;
for (i = 0; i < 12; i++)
{
cout << a[i].stn <<"";
}
cout << endl;
break;
case 1:
QuickSort(a, 0, 11);
cout <<"快速排序结果"<< endl;
for (i = 0; i < 12; i++)
{
cout << a[i].stn <<"";
}
cout << endl;
break;
case 3:
InsertSort(a, 12);
cout <<"直接插入结果"<< endl;
for (i = 0; i < 12; i++)
{
cout << a[i].stn <<"";
}
cout << endl;
break;
case 4:
SelectSort(a, 12);
cout <<"直接选择结果"<< endl;
for (i = 0; i < 12; i++)
{
cout << a[i].stn <<"";
}
cout << endl;
break;
case 5:
BubbleSort(a, 12);
cout <<"气泡排序结果"<< endl;
for (i = 0; i < 12; i++)
{
cout << a[i].stn <<"";
}
cout << endl;
break;
default:
cout <<"输入错误";
break;
}
goto loop;
}
五、实验数据分析及处理
六、实验结论与感悟(或讨论)
因为在快速排序方法中存在着不相邻元素之间的交换,所以快速排序也是一种不稳定的排序方法。