数据结构实验报告内排序
数据结构与算法实验报告及代码-内排序
实验五内排序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.实验数据及分析实验过程的描述。
数据结构实验报告-排序
本章共8道实验题目。
一、直接插入排序1. 定义顺序表的存储结构2. 初始化顺序表为空表3. 输入10个元素创建含有10个元素的顺序表4. 输出顺序表5. 对顺序表进行直接插入排序(InsertSort)6. 输出排序后的顺序表例如:11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序:#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;//此处定义直接插入排序函数int a[20];int main(){int InsertSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}二、折半插入排序1. 定义顺序表的存储结构2. 初始化顺序表为空表3. 输入10个元素创建含有10个元素的顺序表4. 输出顺序表5. 对顺序表进行折半插入排序(BInsertSort)6. 输出排序后的顺序表例如:11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序:#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;//此处定义折半插入排序函数int a[20];int main(){int BInsertSort ;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}三、希尔排序1. 定义顺序表的存储结构2. 初始化顺序表为空表3. 输入10个元素创建含有10个元素的顺序表4. 输出顺序表5. 对顺序表进行希尔排序(ShellSort)6. 输出排序后的顺序表例如:11 938 669 507 117 261 708 343 300 602 11 938 669 507 117 261 708 343 300 602 11 117 261 300 343 507 602 669 708 938 程序:#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;int a[20];int main(){int ShellSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}四、冒泡排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行冒泡排序(BubbleSort)6.输出排序后的顺序表例如:11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序:#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;int a[20];int main(){int BubbleSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}五、快速排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行快速排序(QuickSort)6.输出排序后的顺序表例如:11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序:#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;int a[20];int main(){int QuickSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort (a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}六、简单选择排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行简单选择排序(SelectSort)6.输出排序后的顺序表例如:11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 602 11 117 261 300 343 507 602 669 708 938 程序:#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;int a[20];int main(){int SelectSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}七、堆排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行堆排序(HeapSort)6.输出排序后的顺序表例如:11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序:#include <iostream>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;Status InitList(SqList &L){L.length=0;return 0;}Status CreateList(SqList &L,int n){if(!L.r||n<1||n>MAXSIZE) return ERROR;//cout<<"\n请输入"<<n<<"个元素(用空格隔开):";for(int i=1;i<=n;i++)cin>>L.r[i].key;L.length=n;return OK;}void ListTraverse(SqList L){//cout<<"L=(";for(int i=1;i<=L.length;i++)cout<<L.r[i].key<<' ';//if(L.length) cout<<'\b';//cout<<")";cout<<endl;}void HeapSort(SqList &L){int value = 0;for(int i = 0;i<L.length;i++)for(int j = 0;j<L.length-i;j++){if(L.r[j].key>L.r[j+1].key){value = L.r[j].key;L.r[j].key= L.r[j+1].key;L.r[j+1].key = value;}}int main(){SqList L;InitList(L);CreateList(L,10);ListTraverse(L);HeapSort(L);ListTraverse(L);return 0;}八、归并排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行二路归并排序(MergeSort)6.输出排序后的顺序表例如:11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序:#include <iostream>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef structKeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;Status InitList(SqList &L){L.length=0;return 0;}Status CreateList(SqList &L,int n){if(!L.r||n<1||n>MAXSIZE) return ERROR;//cout<<"\n请输入"<<n<<"个元素(用空格隔开):";for(int i=1;i<=n;i++)cin>>L.r[i].key;L.length=n;return OK;}void ListTraverse(SqList L){//cout<<"L=(";for(int i=1;i<=L.length;i++)cout<<L.r[i].key<<' ';//if(L.length) cout<<'\b';//cout<<")";cout<<endl;}void MSort(){}void Merge(){}void MergeSort(SqList &L){int value = 0;for(int i = 0;i<L.length;i++)for(int j = 0;j<L.length-i;j++){if(L.r[j].key>L.r[j+1].key){value = L.r[j].key;L.r[j].key= L.r[j+1].key;L.r[j+1].key = value;}}}int main(){SqList L;InitList(L);CreateList(L,10);ListTraverse(L);MergeSort(L);ListTraverse(L);return 0;}。
北邮数据结构实验报告-排序
北邮数据结构实验报告-排序北邮数据结构实验报告-排序一、实验目的本实验旨在掌握常见的排序算法,包括冒泡排序、插入排序、选择排序、快速排序、归并排序等,并通过实际编程实现对数字序列的排序。
二、实验内容1.冒泡排序冒泡排序是一种简单的排序算法,其基本思想是依次比较相邻的两个元素,并按照从小到大或从大到小的顺序交换。
具体步骤如下:- 从待排序序列的第一个元素开始,依次比较相邻的两个元素;- 如果前面的元素大于后面的元素,则交换这两个元素的位置;- 重复上述步骤,直到整个序列有序。
2.插入排序插入排序是一种简单且直观的排序算法,其基本思想是将待排序序列分为已排序和未排序两部分,每次从未排序部分中选择一个元素插入到已排序部分的合适位置。
具体步骤如下:- 从待排序序列中选择一个元素作为已排序部分的第一个元素;- 依次将未排序部分的元素插入到已排序部分的合适位置,使得已排序部分保持有序;- 重复上述步骤,直到整个序列有序。
3.选择排序选择排序是一种简单且直观的排序算法,其基本思想是每次选择未排序部分中的最小(或最大)元素,并将其放在已排序部分的末尾。
具体步骤如下:- 在未排序部分中选择最小(或最大)的元素;- 将选择的最小(或最大)元素与未排序部分的第一个元素交换位置;- 重复上述步骤,直到整个序列有序。
4.快速排序快速排序是一种高效的排序算法,其基本思想是通过一趟排序将待排序序列分割成两部分,其中一部分的元素都比另一部分的元素小。
具体步骤如下:- 选择一个枢轴元素(一般选择第一个元素);- 将待排序序列中小于枢轴元素的元素放在枢轴元素的左侧,大于枢轴元素的元素放在枢轴元素的右侧;- 对枢轴元素左右两侧的子序列分别进行递归快速排序;- 重复上述步骤,直到整个序列有序。
5.归并排序归并排序是一种高效的排序算法,其基本思想是将待排序序列划分成足够小的子序列,然后对这些子序列进行两两合并,最终形成有序的序列。
具体步骤如下:- 将待排序序列递归地划分成足够小的子序列;- 对每个子序列进行归并排序;- 合并相邻的子序列,直到整个序列有序。
数据结构实验报告内排序
实验题目:内排序一、实验目的和任务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;}五、实验数据分析及处理六、实验结论与感悟(或讨论)因为在快速排序方法中存在着不相邻元素之间的交换,所以快速排序也是一种不稳定的排序方法。
数据结构排序算法实验报告
移动次数 735219 247071 2997 7296 22836 4233
乱序 2 比较次数 496238 255211 499500 12927 14868 3788
移动次数 762636 256210 2997 7449 22 242989 499500 12951 14845 3818
希尔排序:void ShellSort(Element *list,int n) 记录移动和比较次数的变量:int countlm=0,countlc=0 希尔排序是将文件分组,然后进行插入排序,因此 countlm,countlc 的增量方式与直 接插入排序相同。
堆排序:void HeapSort(Element *list,const int n) 记录移动和比较次数的变量:int countrm=0,countrc=0 首先进行初始建堆 void Restore(Element *tree,const int root,const int n),将待排序文 件保存在完全二叉树中,从最后一个非叶节点开始,将其孩子结点与其进行比较, 每比较一次 countrc 加 1,若孩子结点比其大,二者交换 countrm 加 3,直到任意结 点的关键词大于等于它的两个孩子结点。在进行堆排序,将根节点与最后一个叶节 点交换,countrm 加 3,再进行初始建堆,直至完全排好序。
数据结构实验报告-实验5-排序
数据结构实验报告实验名称:排序学号:姓名:实验日期:2016.07.01一、实验目的至少掌握一种排序算法二、实验内容随机生成10个从1-100之间的随机数,编程实现至少一种排序算法,对该数据进行排序。
要求1、要排序的数据随机生成2、先升序排序一次,再用同样的算法降序排序一次(2)分析(3)实验代码#include <stdio.h>#include <stdlib.h>#include <time.h>typedef struct{int key;}keytype;typedef struct{ keytype r[1000];int length;}sqlist;/*产生随机数*/void creat(sqlist *l){int i;printf("请输入要产生的随机数个数:");scanf("%d",&l->length);srand((unsigned)time(NULL));for(i=1;i<=l->length;i++){l->r[i].key = rand() %900+100;printf("%d ",l->r[i].key);}printf("\n");}/*交换顺序表中子表r[low...high]的记录,使枢轴记录到位,并返回其所在的位置*/int partion(sqlist *l,int low,int high){ int pivotkey;l->r[0]=l->r[low];pivotkey=l->r[low].key;while(low<high){ while(low<high&&l->r[high].key>=pivotkey) --high;l->r[low]=l->r[high];while(low<high&&l->r[low].key<=pivotkey) ++low;l->r[high]=l->r[low];}l->r[low]=l->r[0];return low;}/*快速排序*/void Qsort(sqlist *l,int low,int high){ int pivotloc;if(low<high){ pivotloc=partion(l,low,high);Qsort(l,low,pivotloc-1);Qsort(l,pivotloc+1,high);}}/*显示顺序表*/void display(sqlist *l){ int i;for(i=1;i<=l->length;i++)printf("%-4.2d",i);printf("\n");for(i=1;i<=2*l->length;i++)printf("--");printf("\n");for(i=1;i<=l->length;i++)printf("%-4.2d",l->r[i].key);}/*主函数*/void main(){sqlist t;creat(&t);Qsort(&t,1,t.length);printf("\n\n");printf("快速排序:\n");display(&t);}三、实验小结。
数据结构实验报告排序
数据结构实验报告排序数据结构实验报告:排序引言:排序是计算机科学中常见的算法问题之一,它的目标是将一组无序的数据按照特定的规则进行排列,以便于后续的查找、统计和分析。
在本次实验中,我们将学习和实现几种常见的排序算法,并对它们的性能进行比较和分析。
一、冒泡排序冒泡排序是最简单的排序算法之一,它通过不断交换相邻的元素,将较大(或较小)的元素逐渐“冒泡”到数组的一端。
具体实现时,我们可以使用两层循环来比较和交换元素,直到整个数组有序。
二、插入排序插入排序的思想是将数组分为两个部分:已排序部分和未排序部分。
每次从未排序部分中取出一个元素,插入到已排序部分的适当位置,以保持已排序部分的有序性。
插入排序的实现可以使用一层循环和适当的元素交换。
三、选择排序选择排序每次从未排序部分中选择最小(或最大)的元素,与未排序部分的第一个元素进行交换。
通过不断选择最小(或最大)的元素,将其放置到已排序部分的末尾,从而逐渐形成有序序列。
四、快速排序快速排序是一种分治的排序算法,它通过选择一个基准元素,将数组划分为两个子数组,其中一个子数组的所有元素都小于等于基准元素,另一个子数组的所有元素都大于基准元素。
然后对两个子数组分别递归地进行快速排序,最终将整个数组排序。
五、归并排序归并排序也是一种分治的排序算法,它将数组划分为多个子数组,对每个子数组进行排序,然后再将排好序的子数组合并成一个有序的数组。
归并排序的实现可以使用递归或迭代的方式。
六、性能比较与分析在本次实验中,我们对以上几种排序算法进行了实现,并通过对不同规模的随机数组进行排序,比较了它们的性能。
我们使用了计算排序时间的方式,并记录了每种算法在不同规模下的运行时间。
通过对比实验结果,我们可以得出以下结论:1. 冒泡排序和插入排序在处理小规模数据时表现较好,但在处理大规模数据时性能较差,因为它们的时间复杂度为O(n^2)。
2. 选择排序的时间复杂度也为O(n^2),与冒泡排序和插入排序相似,但相对而言,选择排序的性能稍好一些。
数据结构内排序实验报告
数据结构内排序实验报告数据结构内排序实验报告一、实验目的本实验旨在熟悉数据结构内排序算法的实现过程,比较各种内排序算法的效率和性能,并掌握它们的优缺点。
二、实验内容⒈实验环境搭建在实验开始前,需要搭建适当的实验环境,包括编程语言、集成开发环境(IDE)等。
⒉内排序算法实现选择合适的内排序算法,如冒泡排序、插入排序、选择排序、快速排序等,对给定的待排序数据进行实现。
⒊程序测试编写测试程序,随机生成一定量的数据,对每个内排序算法进行测试,并记录运行时间和比较次数。
⒋数据比较与分析将各个内排序算法的运行时间和比较次数进行比较,分析它们的优劣势。
⒌实验结论结合实验结果,给出对内排序算法的选择建议,并对实验过程中的问题进行总结。
三、实验步骤与介绍⒈实验环境搭建在本次实验中,我们选择使用C++编程语言,并搭建Visual Studio作为集成开发环境。
该环境提供了丰富的调试和测试工具,适合本次实验的需求。
⒉内排序算法实现我们选择了三种常见的内排序算法进行实现,包括冒泡排序、插入排序和快速排序。
a) 冒泡排序冒泡排序是一种交换排序算法,通过不断比较相邻元素并交换位置来实现排序。
具体实现步骤如下:- 从待排序数组的第一个元素开始,不断比较相邻两元素的大小。
- 如果前一个元素大于后一个元素,则交换它们的位置。
- 继续比较下一对元素,直到最后一个元素。
- 重复以上步骤,直到排序完成。
b) 插入排序插入排序是一种直接插入排序算法,通过不断将待排序元素插入已排序部分的合适位置来实现排序。
具体实现步骤如下:- 从待排序数组的第二个元素开始,依次将元素与前面已排好序的元素进行比较。
- 如果前一个元素大于待排序元素,则将前一个元素后移一位。
- 继续比较前一个元素,直到找到合适的位置插入待排序元素。
- 重复以上步骤,直到排序完成。
c) 快速排序快速排序是一种分治排序算法,通过不断地将数组分成两部分并对子数组递归进行排序来实现整体排序。
数据结构课程设计实验报告-内部排序算法比较
内部排序算法比较【实验简介】1、在教科书各种内部排序算法的时间复杂度分析结果只给出了算法执行的时间的阶,或大概的执行时间,如:直接插入排序即时间复杂度为O(n*n)2、通过五组随机数据、一组正序数据与一组逆序数据比较6种常用的内部算法(起泡排序、直接插入排序、简单选择排序、快速查找排序、希尔排序、堆排序)的关键字比较次数和关键字移动次数,以取得直观感受;3、用五组不同的长度不小于100的数据进行测试,并对测试结果作出简单的分析,对得出结果拨动大小的进行解释;【设计模块】【对应模块算法说明】(1) 此算法程序中需要用到顺序表数据类型,数据元素的类型定义如下:typedef struct{KeyType key; //关键字项}RedType;typedef struct{RedType r[MAXSIZE+1]; //0号单元闲置或用作哨兵单元int length; //顺序表长度int info; //记录关键字移动次数int cmp; //关键字的比较次数}Sqlist;(2) 本实验用到六种排序算法,一个主函数和菜单函数,其中排序算法分别为起泡排序、直接插入排序、简单选择排序、快速查找排序、希尔排序、堆排序;相应时间复杂度分析如下:起泡排序:若待排序列为“正序”,则需进行一趟排序在排序过程中关键字需进行n-1次比较,无须移动纪录;若是“逆序”,则进行n-1趟排序,需n(n-1)/2次比较,并坐等数量级的移动,因此总的事件复杂度为O(n2);直接插入排序待排序纪录是随机的,关键字间的移动次数和比较次数的平均值约为n*n/4,即时间复杂度为O(n2);简单的选择排序虽然在排序过程中所需要的移动次数较少,最小时为0,最大时为3(n-1);但是关键字的比较次数总是相同的,均为n(n-1)/2,因此,时间复杂度亦为O(n2);快速排序其平均时间是kn*㏑n,其中n为待排序列中纪录的个数,k为某个常数,其时间复杂度为O(n*㏑n);希尔排序当增序序列为dlta[k]=2t-k+1-1时,时间复杂度为O(n3/2),其中t为排序趟数,1≤k≤t≤㏒2(n+1);堆排序此排序对于含n个元素的序列排序时,总共进行的关键字比较次数不超过4n,且在最坏的情况下,其时间复杂度为O(n*㏑n);算法分析如下:①冒泡排序该算法的的思路是首先将第1个记录的关键字负值给L.r[0],然后用L.r[0]与第(i+1)个记录的关键字比较,若为逆序,则交换第i与第i+1两记录的位置,然后让i加1,重复以上操作,直至i=n-1为止;依次进行第二趟、第三趟……作同样的操作,直至所有的记录按正序排列(一般需要n-1趟比较,第i趟从L.r[1]到L.r[n-i+1]依次比较,1≦ i ≦n-i,比较结果是让其中最大的记录放在L.r[n-i+1]的位置)void BubbleSort(Sqlist *L) //冒泡排序{for(i=0;i<L->length;i++){L->r[0]=L->r[1];for(j=1;j<N-i;j++)if(L->r[0].key>=L->r[j+1].key)L->r[j] L->r[j+1]; //交换两记录的位置elseL->r[0]=L->r[j+1]; //保证L->r[0]始终为较大的记录L->r[j+1]=L->r[0]; //把最大的记录放到祠堂排序的最高位置}printf(L->r[MAXSIZE]);//输出排序后数组和相关数据}②直接插入排序本算法的思路是,把L->r[0]设置为哨兵,排序时把第i个记录复制给哨兵,并于其前的i-1个记录进行比较,找到第一个比起大的记录,利用循环让记录后移,把其放到第一个比起大的记录前面。
北邮数据结构实验报告排序
数据结构实验报告实验名称:实验四——排序学生姓名:班级:班内序号:学号:日期:2014年12月19日1.实验要求实验目的通过实现下述实验内容,学习、实现、对比各种排序算法,掌握各种排序算法的优劣,以及各种算法使用的情况。
实验内容使用简单数组实现下面各种排序算法,并进行比较。
排序算法:1、插入排序2、希尔排序3、冒泡排序4、快速排序5、简单选择排序6、堆排序(选作)7、归并排序(选作)8、基数排序(选作)9、其他要求:1、测试数据分成三类:正序、逆序、随机数据2、对于这三类数据,比较上述排序算法中关键字的比较次数和移动次数(其中关键字交换计为3次移动)。
3、对于这三类数据,比较上述排序算法中不同算法的执行时间,精确到微秒(选作)4、对2和3的结果进行分析,验证上述各种算法的时间复杂度编写测试main()函数测试线性表的正确性。
2. 程序分析首先,题目要求测试不同的数据,所以可以手动输入待排序元素。
其次,由于对一组数据要求用不同的排序算法来处理,所以需要一个复制函数把排序前的无序数组寄存出去,为下一次排序做准备。
再次,由于每次排序后都需要把排序后的结果打印出来,代码是一样的,根据相同的代码可以封装成一个函数的思想,所以还需增加一个打印函数。
2.1 存储结构本程序采用简单数组来储存输入的待排序数组2.2 关键算法分析核心算法思想:1. 利用教材讲述的基本算法思想,实现七种排序算法,统计其运行相关数据。
2. 将七种排序函数入口地址作为函数指针数组,实现快速调用和统计。
使得程序代码可读性增、结构更加优化。
关键算法思想描述和实现:关键算法1:实现七种算法的基本排序功能。
1、插入排序:依次将待排序的序列中的每一个记录插入到先前排序好的序列中,直到全部记录排序完毕。
插入排序的思想是:每次从无序区取一元素将其添加到有序区中。
2、希尔排序:先将整个序列分割成若干个子列,分别在各个子列中运用直接插入排序,待整个序列基本有序时,再对全体记录进行一次直接插入排序。
数据结构排序实验报告
引言概述:数据结构排序实验是计算机科学与技术专业中一项重要的实践课程。
通过实验,可以深入理解和掌握不同排序算法的原理、特点和性能表现。
本文将针对数据结构排序实验进行详细的阐述和总结,包括实验目的、实验内容、实验结果分析和总结。
一、实验目的1. 加深对数据结构排序算法的理解:通过实验,掌握不同排序算法的工作原理和实现方式。
2. 分析和比较不同排序算法的性能:对比不同排序算法在不同数据规模下的时间复杂度和空间复杂度,理解它们的优劣势。
3. 提高编程和算法设计能力:通过实验的编写,提升对排序算法的实现能力和代码质量。
二、实验内容1. 选择排序算法:选择排序是一种简单直观的排序算法,将序列分为有序和无序两部分,每次从无序部分选择最小(最大)元素,放到有序部分的末尾(开头)。
- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析2. 插入排序算法:插入排序逐步构建有序序列,对于未排序的元素,在已排序序列中从后向前扫描,找到对应位置插入。
- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析3. 快速排序算法:快速排序利用分治的思想,将序列分为左右两部分,选取基准元素,将小于基准的放在左边,大于基准的放在右边,递归地对左右部分进行排序。
- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析4. 归并排序算法:归并排序是一种稳定的排序算法,通过将序列分为若干子序列,分别进行排序,然后再将排好序的子序列合并成整体有序序列。
- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析5. 堆排序算法:堆是一种特殊的树状数据结构,堆排序利用堆的性质进行排序,通过构建大顶堆或小顶堆,并逐个将堆顶元素移出形成有序序列。
- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析三、实验结果分析1. 比较不同排序算法的执行时间:根据实验数据和分析,对比不同排序算法在不同数据规模下的执行时间,并针对其时间复杂度进行验证和分析。
数据结构排序实验报告
数据结构排序实验报告一、实验目的本次数据结构排序实验的主要目的是深入理解和掌握常见的排序算法,包括冒泡排序、插入排序、选择排序、快速排序和归并排序,并通过实际编程和实验分析,比较它们在不同规模数据下的性能表现,从而为实际应用中选择合适的排序算法提供依据。
二、实验环境本次实验使用的编程语言为 Python 3x,开发环境为 PyCharm。
实验中使用的操作系统为 Windows 10。
三、实验原理1、冒泡排序(Bubble Sort)冒泡排序是一种简单的排序算法。
它重复地走访要排序的数列,一次比较两个数据元素,如果顺序不对则进行交换,并一直重复这样的走访操作,直到没有要交换的数据元素为止。
2、插入排序(Insertion Sort)插入排序是一种简单直观的排序算法。
它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入,直到整个数组有序。
3、选择排序(Selection Sort)首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。
以此类推,直到所有元素均排序完毕。
4、快速排序(Quick Sort)通过一趟排序将待排记录分隔成独立的两部分,其中一部分记录的关键字均比另一部分关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序。
5、归并排序(Merge Sort)归并排序是建立在归并操作上的一种有效、稳定的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。
将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。
四、实验步骤1、算法实现使用 Python 语言分别实现上述五种排序算法。
为每个算法编写独立的函数,函数输入为待排序的列表,输出为排序后的列表。
2、生成测试数据生成不同规模(例如 100、500、1000、5000、10000 个元素)的随机整数列表作为测试数据。
- 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;
}
五、实验数据分析及处理
六、实验结论与感悟(或讨论)
因为在快速排序方法中存在着不相邻元素之间的交换,所以快速排序也是一种不稳定的排序方法。