北理工数据结构实验 排序

合集下载

北工大 数据结构9 排序

北工大 数据结构9 排序

插入排序
希尔排序
基本思想:将整个待排序记录分割成若干个子序列, 在子序列内分别进行直接插入排序,待整个序列中的 记录基本有序时,对全体记录进行直接插入排序。 需解决的关键问题? (1)应如何分割待排序记录,才能保证整个序列逐步 向基本有序发展? (2)子序列内如何进行直接插入排序?
希尔排序
分割待排序记录的目的? 1. 减少待排序记录个数; 2. 使整个序列向基本有序发展。 基本有序:接近正序,例如{1, 2, 8, 4, 5, 6, 7, 3, 9}; 局部有序:部分有序,例如{6, 7, 8, 9, 1, 2, 3, 4, 5}。 局部有序不能提高直接插入排序算法的时间性能。 启示? 子序列的构成不能是简单地“逐段分割”,而是将相距某个“ 增量”的记录组成一个子序列。
排序算法的存储结构
从操作角度看,排序是线性结构的一种操作,待 排序记录可以用顺序存储结构或链接存储结构存储。 假定1:采用顺序存储结构,关键码为整型,且记录 只有关键码一个数据项。 int r[n+1]; //待排序记录存储在r[1]~r[n],r[0]留做他用 假定2:将待排序的记录序列排序为升序序列。
直接插入排序算法性能分析
最好情况下(正序): 比较次数:n-1 移动次数:0 时间复杂度为O(n)。
4 3 2 5 4 3 2 1 4 5 4 3 2 3 3 5 4 3 2 2 2 5 4 1 1 1 1 5
最坏情况下(逆序或反序): 1 n 比较次数:∑ i = (n +2)(n −1)
2 n (n +4)(n −1) = (i +1) 移动次数:∑ 2 i=2
排序的基本概念
排序算法的稳定性:假定在待排序的记录集中,存在多个具有 相同键值的记录,若经过排序,这些记录的相对次序仍然保持 不变,即在原序列中,ki=kj且ri在rj之前,而在排序后的序列 中,ri仍在rj之前,则称这种排序算法是稳定的;否则称为不 稳定的。 学号 0001 0002 0003 … 姓名 王 军 李 明 汤晓影 … 高数 85 64 85 … 英语 68 72 78 … 思想品德 88 92 86 …

数据结构实验四题目一排序实验报告

数据结构实验四题目一排序实验报告

数据结构实验报告实验名称:实验四——排序学生:XX班级:班序号:学号:日期:1.实验要求实验目的:通过选择实验容中的两个题目之一,学习、实现、对比、各种排序的算法,掌握各种排序算法的优劣,以及各种算法使用的情况。

题目1:使用简单数组实现下面各种排序算法,并进行比较。

排序算法如下:1、插入排序;2、希尔排序;3、冒泡排序;4、快速排序;5、简单选择排序;6、堆排序;7、归并排序;8、基数排序(选作);9、其他。

具体要求如下:1、测试数据分成三类:正序、逆序、随机数据。

2、对于这三类数据,比较上述排序算法中关键字的比较次数和移动次数(其中关键字交换记为3次移动)。

3、对于这三类数据,比较上述排序算法中不同算法的执行时间,精确到微妙。

4、对2和3的结果进行分析,验证上述各种算法的时间复杂度。

5、编写main()函数测试各种排序算法的正确性。

2. 程序分析2.1 存储结构存储结构:数组2.2 关键算法分析一、关键算法:1、插入排序a、取排序的第二个数据与前一个比较b、若比前一个小,则赋值给哨兵c、从后向前比较,将其插入在比其小的元素后d、循环排序2、希尔排序a、将数组分成两份b、将第一份数组的元素与哨兵比较c、若其大与哨兵,其值赋给哨兵d、哨兵与第二份数组元素比较,将较大的值赋给第二份数组e、循环进行数组拆分3、对数据进行编码a、取数组元素与下一个元素比较b、若比下一个元素大,则与其交换c、后移,重复d、改变总元素值,并重复上述代码4、快速排序a、选取标准值b、比较高低指针指向元素,若指针保持前后顺序,且后指针元素大于标准值,后指针前移,重新比较c、否则后面元素赋给前面元素d、若后指针元素小于标准值,前指针后移,重新比较e、否则前面元素赋给后面元素5、简单选择排序a、从数组中选择出最小元素b、若不为当前元素,则交换c、后移将当前元素设为下一个元素6、堆排序a、生成小顶堆b、将堆的根节点移至数组的最后c、去掉已做过根节点的元素继续生成小顶堆d、数组倒置7、归并排序a、将数组每次以1/2拆分,直到为最小单位b、小相邻单位数组比较重排合成新的单位c、循环直至完成排序二、代码详细分析:1、插入排序关键代码:①取排序的第二个数据与前一个比较:if(r[i]<r[i-1])②若比前一个小,则赋值给哨兵:r[0]=r[i];③从后向前比较,将其插入在比其小的元素后:for(j=i-1;r[0]<r[j];j--){r[j+1]=r[j];a++;} r[j+1]=r[0];④循环排序2、希尔排序关键代码:①将数组分成两份:d=n/2②将第一份数组的元素与哨兵比较:for(int i=d+1;i<=n;i++)③若其大与哨兵,其值赋给哨兵:if(r[0]<r[i-d]){ r[0]=r[i];}④哨兵与第二份数组元素比较,将较大的值赋给第二份数组:for(j=i-d;j>0&&r[0]<r[j];j=j-d) {r[j+d]=r[j]; }⑤循环进行数组拆分:for(int;d>=1;d=d/2)3、冒泡排序关键代码:①取数组元素与下一个元素比较: for(int i=1;i<bound;i++)if(r[i]>r[i+1])②若比下一个元素大,则与其交换: r[0]=r[i]; r[i]=r[i+1]; r[i+1]=r[0];③后移,重复:for(int i=1;i<bound;i++)④改变总元素值,并重复上述代码:int bound=pos;4、快速排序关键代码:①选取标准值:r[0]=r[i]②比较高低指针指向元素,若指针保持前后顺序,且后指针元素大于标准值,后指针前移,重新比较:while(i<j&&r[j]>=flag) {j--;}③否则后面元素赋给前面元素:r[i]=r[j];④若后指针元素小于标准值,前指针后移,重新比较:while(i<j&&r[i]<=flag){i++;}⑤否则前面元素赋给后面元素:r[j]=r[i];5、简单选择排序关键代码:①从数组中选择出最小元素: for(int j=i+1;j<=n;j++)②{if(r[j]<r[index]) index=j; }③若不为当前元素,则交换:if(index!=i) {r[0]=r[i]; r[i]=r[index];r[index]=r[0];}④后移将当前元素设为下一个元素:for(int i=1;i<n;i++)6、堆排序关键代码:①生成小顶堆:while(j<=m) {if(j<m&&r[j]>r[j+1]) {j++;}②if(r[i]<r[j]) {break; }③else{ int x; x=r[i]; r[i]=r[j]; r[j]=x; i=j; j=2*i; }}④将堆的根节点移至数组的最后: x=r[1]; r[1]=r[n-i+1]; r[n-i+1]=x;⑤去掉已做过根节点的元素继续生成小顶堆:sift(r,1,n-i,x,y);⑥数组倒置输出: for(int i=n;i>0;i--)cout<<r[i]<<" ";7、归并排序关键代码:①将数组每次以1/2拆分,直到为最小单位: mid=(low+high)/2;②小相邻单位数组比较重排合成新的单位:while(i<=m&&j<=high)if(L.r[i]<=L.r[j]) t[k++]=L.r[i++];else t[k++]=L.r[j++];while(i<=m) t[k++]=L.r[i++];while(j<=high) t[k++]=L.r[j++];for(i=low,k=0;i<=high;i++,k++) L.r[i]=t[k];三、计算关键算法的时间、空间复杂度插入排序O(n2)希尔排序O(n2)冒泡排序O(n2)快速排序O(nlog2n)简单选择排序O(n2)堆排序O(nlog2n)归并排序O(nlog2n)3. 程序运行结果1、测试主函数流程:流程图如图所示流程图示意图程序运行结果图如下:2、测试条件:按题目要求分别输入同组数据的正序、逆序、随机序列进行测试。

北京理工大学数据结构实验报告2

北京理工大学数据结构实验报告2

《数据结构与算法统计》实验报告学院:班级:学号:姓名:一、实验目的⑴熟悉VC++6.0环境,学习使用C++实现栈的存储结构;⑵通过编程、上机调试,进一步理解栈的基本概念;⑶锻炼动手编程,独立思考的能力。

二、实验内容实现简单计算器的功能,请按照四则运算加、减、乘、除、幂(^)和括号的优先关系和惯例,编写计算器程序。

要求支持运算符:+、-、*、/、%、()和=:①从键盘输入一个完整的表达式,以回车作为表达式输入结束的标志;②输入表达式中的数值均为大于等于零的整数,如果中间计算过程中出现小数也只取整进行计算。

例如,输入:4+2*5= 输出:14输入:(4+2)*(2-10)= 输出:-48三、程序设计1、概要设计为实现上述功能,应使用两个栈,分别寄存操作数和运算符。

为此需要栈的抽象数据结构。

⑴栈的抽象数据类型定义如下:ADT Stack{数据对象:D = { ai | ai ∈ElemSet, i=1,…,n,n≥0 }数据关系:R1 = { <ai-1, ai> | ai-1,ai ∈D, i=2, …,n }基本操作:InitStack1(SqStack1 &S)操作结果:创建一个空栈S,以存储运算符InitStack2(SqStack2 &S)操作结果:创建一个空栈S,以存储操作数Push1(SqStack1 &S,char e)初始条件:栈S已存在操作结果:插入运算符e作为新的栈顶元素Push2(SqStack2 &S,int e)初始条件:栈S已存在操作结果:插入操作数e作为新的栈顶元素Precede(char d,char c)初始条件:d,c为运算符操作结果:若d优先级大于c,返回>;若d优先级小于c,返回<;若d优先级等于c,返回=;GetTop1(SqStack1 &S)初始条件:栈S已存在且非空操作结果:用e返回寄存运算符栈S的栈顶元素GetTop2(SqStack2 &S)初始条件:栈S已存在且非空操作结果:用e返回寄存操作数栈S的栈顶元素Pop1(SqStack1 &S,char &e)初始条件:栈S已存在且非空操作结果:删除寄存运算符栈S的栈顶元素Pop2(SqStack2 &S,int &e)初始条件:栈S已存在且非空操作结果:删除寄存操作数栈S的栈顶元素Operate(int a,char theta,int b)初始条件:a,b为整数,theta为运算符操作结果:返回a与b运算的结果EvaluateExpression()初始条件:输入合法的表达式操作结果:返回表达式的值}ADT Stack⑵主程序流程调用EvaluateExpression()函数计算表达式的值,输出在屏幕上。

《数据结构》实验报告——排序

《数据结构》实验报告——排序

《数据结构》实验报告排序实验题目:输入十个数,从插入排序,快速排序,选择排序三类算法中各选一种编程实现。

实验所使用的数据结构内容及编程思路: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为止。

北京理工大学数据结构实验报告选作1

北京理工大学数据结构实验报告选作1

《数据结构与算法统计》实验报告学院:班级:学号:姓名:一、实验目的1.熟悉VC++6.0环境,学习使用C++实现链表的存储结构;2.通过编程,上机调试,进一步理解线性表、链表的基本概念。

二、实验内容归并顺序表(选作)。

请按以下要求编程实现:①从键盘输入两个升序排列的整数序列linka和linkb,每个序列以输入0为结束标记。

②将链表linka和linkb归并为linkc,linkc仍然为升序排列。

归并完成后,linka和linkb为空表。

输出linkc。

③对linkc进行处理,保持升序不变,删除其中重复的整数,对重复的整数只保留一个,输出删除重复整数后的链表。

例如:linka输入为:10 20 30 40 50 0linkb输入为:15 20 25 30 35 40 45 50 0归并后的linkc为:10 15 20 20 25 30 30 35 40 40 45 50 50删除重复后的linkc为:10 15 20 25 30 35 40 45 50三、程序设计1、概要设计说明程序的主要功能,主程序的流程以及各个程序模块之间的调用关系,给出主要流程图。

应用单链线性表寄存数字序列。

⑴单链线性表的抽象数据类型线性表的定义如下:ADT LinkList {数据对象:D = { ai | ai ∈ElemSet, i=1,…,n,n≥0 }数据关系:R1 = { <ai-1, ai> | ai-1,ai ∈D, i=2, …,n }基本操作:Creat(LinkList &L)操作结果:构造单链线性表L。

MergeList(LinkList &La,LinkList &Lb,LinkList &Lc)初始条件:单链线性表La,Lb,Lc已经存在。

操作结果:归并La,Lb得到新的单链线性表Lc,Lc的元素也按值非递减排列。

Delete(LinkList &L)初始条件:链表L已经存在。

北理工数据结构实验三

北理工数据结构实验三

《数据结构与算法设计》实验报告——实验三学院:班级:学号:姓名:一、实验目的1.通过实验实践、巩固二叉树和队列的相关操作;2.熟悉VC环境,加强编程、调试的练习;3.用C语言实现二叉树和队列的抽象数据类型;4.用C语言编写递归函数,实现生成二叉树和遍历二叉树;5.用队列实现二叉树的层次遍历;6.理论知识与实际问题相结合,利用上述基本操作用多种方式遍历二叉树。

二、实验内容1、遍历二叉树。

请输入一棵二叉树的扩展的前序序列,经过处理后生成一棵二叉树,然后对于该二叉树输出前序、中序和后序遍历序列。

2、选做:按层次遍历二叉树。

三、程序设计1、概要设计为实现上述程序功能,需要建立抽象数据类型:二叉树和队列。

(1)、定义抽象数据类型二叉树的抽象数据类型定义为:ADT BinaryTree {数据对象D:D是具有相同特性的数据元素的集合。

数据关系R:若D=Φ,则R=Φ,称BinaryTree为空二叉树;若D≠Φ,则R={H},H是如下二元关系;(1)在D中存在惟一的称为根的数据元素root,它在关系H下无前驱;(2)若D-{root}≠Φ,则存在D-{root}={D1,Dr},且D1∩Dr =Φ;(3)若D1≠Φ,则D1中存在惟一的元素x1,<root,x1>∈H,且存在D1上的关系H1 ⊆H;若Dr≠Φ,则Dr中存在惟一的元素xr,<root,xr>∈H,且存在上的关系Hr ⊆H;H={<root,x1>,<root,xr>,H1,Hr};(4)(D1,{H1})是一棵符合本定义的二叉树,称为根的左子树;(Dr,{Hr})是一棵符合本定义的二叉树,称为根的右子树。

基本操作:CreatBiTree(BiTree &T)操作结果:按先序次序建立二叉链表表示的二叉树TPreOrderTraverse(BiTree T)初始条件:二叉树T已经存在操作结果:先序遍历二叉树T ,对每个结点输出其数据元素InOrderTraverse(BiTree T)初始条件:二叉树T已经存在操作结果:中序遍历二叉树T ,对每个结点输出其数据元素PostOrderTraverse(BiTree T)初始条件:二叉树T已经存在操作结果:后序遍历二叉树T ,对每个结点输出其数据元素LevelOrderTraverse(BiTree T)初始条件:二叉树T已经存在操作结果:层次遍历二叉树T ,对每个结点输出其数据元素} ADT BinaryTree队列的抽象数据类型定义为:ADT Stack{数据对象:D={ai|ai∈ElemSet,i=1,2,3……,n,n≥0}数据关系:R1={ <ai-1,ai>|ai∈D,i=1,2,……,n}约定其中a1端为队列头,an端为队列尾基本操作:InitQueue(&Q)功能:构造一个空队列Q。

北京理工大学-数据结构实验报告-实验四--图书管理系统

北京理工大学-数据结构实验报告-实验四--图书管理系统

实验四图书管理系统姓名:任子龙学号:1120140167 班级:05111451一。

需求分析(1)问题描述有一个小型书库保管了大量图书,关于图书有大量信息需要处理,这些信息包括图书的分类、书名、作者名、购买日期、价格等。

现要求编写一个程序以便于对图书的管理。

(2)基本要求:a.建立图书信息.b.提供查找功能,按照多种关键字查找需要的书籍。

例如按书名查找,输入书名后,将显示出该图书的所有信息,或显示指定信息。

c.提供排序功能,按照多种关键字对所有的书籍进行排序,例如按出版日期进行排序。

d.提供维护功能,可以对图书信息进行添加、修改、删除等功能。

(3)数据结构与算法分析将每一本书看作是一个基本单元。

由于涉及添加、修改操作,这里使用了链表作为数据存储结构;同时,考虑到排序功能,尝试使用双向链表。

其中,每本书作为一个结点,数据域包含char 型变量,指针域含有左右指针left和right。

二.概要设计1。

抽象数据类型的定义为实现上述功能,程序中使用了双向链表,只需要定义一种数据类型:typedef struct book{char number[10];char title[20];char author[10];char date[15];char price[10];struct book *right;struct book *left;}BK;注意结点的指针域有left和right两个。

2.本程序包含两个模块(1)主程序模块主函数只包含了Menu_select()函数。

目的是进入主菜单界面,进行功能选择;直到输入操作码0,退出系统;(2)双向链表单元模块——实现书籍信息的链式存储的抽象数据类型.各函数之间的调用关系:三。

详细设计1。

结点类型typedef struct book{char number[10];char title[20];char author[10];char date[15];char price[10];struct book *right;struct book *left;}BK;2.子函数(1)功能菜单调用函数Menu_select()使用户进入主菜单界面,进行功能选择;先进入无限循环,输入操作码进行系统管理工作,直到输入操作码0,退出系统;(2)各种功能函数Initialize()//初始化图书系统信息;Insert()//添加新的图书信息;Sort()//对图书进行排序,本程序可以实现按“图书编号”、“出版日期"、“图书价格”多种关键字进行排序;Search()//实现对图书的查找功能,本程序可以实现按“图书编号"、“出版日期”、“图书价格”多种关键字进行查找;deletebook()//删除无效的图书信息;Print_book()//打印全部图书信息。

北京理工大学《数据结构与算法设计》实验报告实验四

北京理工大学《数据结构与算法设计》实验报告实验四

《数据结构与算法设计》实验报告——实验四学院:班级:学号:姓名:一、实验目的1.通过实验实践、巩固线性表的相关操作; 2.熟悉VC 环境,加强编程、调试的练习; 3.用C 语言实现线性表的抽象数据类型,实现线性表构造、插入、取数据等基本操作; 4. 理论知识与实际问题相结合,利用上述基本操作实现三种排序并输出。

二、实验内容从键盘输入10个数,编程实现分别用插入排序、交换排序、选择排序算法进行排序,输出排序后的序列。

三、程序设计1、概要设计为了实现排序的功能,需要将输入的数字放入线性表中,进行进一步的排序操作。

(1)抽象数据类型:ADT SqList{数据对象:D={|,1,2,,,0}i i a a ElemSet i n n ∈=≥数据关系:R1=11{,|,,1,2,,}i ii i a a a a D i n --<>∈= 基本操作:InPut(SqList &L)操作结果:构造一个线性表L 。

OutPut(SqList L)初始条件:线性表L 已存在。

操作结果:按顺序在屏幕上输出L 的数据元素。

InsertSort(SqList &L)初始条件:线性表L 已存在。

操作结果:对L 的数据元素进行插入排序。

QuickSort(SqList &L)初始条件:线性表L 已存在。

操作结果:对L 的数据元素进行快速排序。

SelectSort(SqList &L)初始条件:线性表L 已存在。

操作结果:对L 的数据元素进行选择排序。

}ADT SqList⑵主程序流程由主程序首先调用InPut(L)函数创建顺序表,调用InsertSort(L)函数进行插入排序,调用OutPut(L)函数显示排序结果。

调用QuickSort(L)函数进行交换排序,调用OutPut(L)函数显示排序结果。

调用SelectSort(L)函数进行选择排序,调用OutPut(L)函数显示排序结果。

《数据结构》 实验报告4

《数据结构》 实验报告4

xxx实验报告课程名称数据结构实验名称实验四排序操作系部班级姓名学号实验时间2012 年12月10日时分~时分地点机位评语指导教师:成绩一、实验目的1. 掌握常用的排序方法,并掌握用高级语言实现排序算法的方法;2. 深刻理解排序的定义和各种排序方法的特点,并能加以灵活应用;3. 了解各种方法的排序过程及其时间复杂度的分析方法。

二、实验内容统计成绩:给出n个学生的考试成绩表,每条信息由姓名和分数组成,试设计一个算法:(1)按分数高低次序,打印出每个学生在考试中获得的名次,分数相同的为同一名次;(2)按名次列出每个学生的姓名与分数。

三、实验步骤1. 定义结构体。

2. 定义结构体数组。

3. 定出主程序,对数据进行排序。

四、程序主要语句及作用1. 程序原代码如下:#include <string.h>#include "stdio.h"#include <malloc.h>#include <conio.h>typedef struct BSTNODE{int data;struct BSTNODE *lchild;struct BSTNODE *rchild;}BSTNODE;BSTNODE* initBST(int n, BSTNODE *p){if(p==NULL){p=(BSTNODE*)malloc(sizeof(BSTNODE));p->lchild=NULL;p->rchild=NULL;p->data=n;}else if(n>p->data)p->rchild=initBST(n,p->rchild);elsep->lchild=initBST(n,p->lchild);return p;}void inorder(BSTNODE *BT){if(BT!=NULL){inorder(BT->lchild);printf("%d ",BT->data);inorder(BT->rchild);}}BSTNODE *search_btree(BSTNODE *root,int key) { if (!root){printf("Emptu btree\n"); return root; }while(root->data!=key){ if(key<root->data)root=root->lchild;elseroot=root->rchild;if(root==0){ printf("Search Failure\n");break ;}} /* while(root->info!=key) */if (root !=0)printf("Successful search\n key=%d\n",root->data);return root ;} /* *search_btree(root,key) */int main(){BSTNODE *p=NULL;int i,n,sd;int a[100];printf("enter the number of nodes:");scanf("%d",&n);printf("enter the number of the tree:");for(i=0;i<n;i++){scanf("%d",&a[i]);p=initBST(a[i],p);}inorder(p);printf("\n please input search data:");scanf("%d",&sd);search_btree(p,sd);getch();return 1;}2. 运行结果截图:五、总结体会本次试验让我学习到了很多也认识到了自己的不足:1.大部分的时间都用在了编程上,主要是因为C语言掌握的问题,C语言基础不好特别是对于C语言中链表的一些定义和基本操作不够熟练,导致在编程过程中还要不断的拿着c语言的教材查找,所以今后还要对C语言多练习,多动手,多思考。

数据结构实验快速排序

数据结构实验快速排序

数据结构实验快速排序快速排序(Quicksort)是一种常用的排序算法,其基本思想是通过一趟排序将待排序序列分割成独立的两部分,其中一部分的所有元素小于等于基准值,而另一部分的所有元素大于等于基准值,然后再对这两部分分别进行快速排序,以达到整个序列有序的目的。

本文将详细介绍快速排序的实现步骤,包括选择基准值、划分操作和递归排序等。

一、选择基准值在快速排序中,我们需要选择一个基准值。

基准值的选择可以影响快速排序的效率,一般选择待排序序列的第一个元素作为基准值。

二、划分操作划分操作是快速排序的核心步骤之一。

在划分操作中,我们需要将待排序序列划分成两部分,一部分的元素小于等于基准值,另一部分的元素大于等于基准值。

具体的划分操作步骤如下:1.设置左右两个指针,分别指向待排序序列的第一个和最后一个元素。

2.左指针向右移动,直到遇到大于等于基准值的元素。

3.右指针向左移动,直到遇到小于等于基准值的元素。

4.如果左指针小于等于右指针,则交换左右指针所指向的元素,并将左指针右移、右指针左移。

5.重复步骤2~4,直到左指针大于右指针。

三、递归排序在划分操作之后,我们得到了两个独立的子序列。

接下来,我们需要将这两个子序列分别进行递归排序,以达到整个序列有序的目的。

具体的递归排序步骤如下:1.如果待排序序列的长度大于1,则进行以下操作:a.以基准值将序列划分成两部分。

b.对左子序列进行递归排序。

c.对右子序列进行递归排序。

2.合并左右子序列和基准值,得到有序序列。

法律名词及注释:1.版权:指对作品享有的全部权利的法律保护,包括复制权、发行权、出租权、表演权、展览权、改编权等。

2.专利:指为了鼓励技术创新而给予的一种专有权,以防止他人在一定时期内未经许可制造、使用或销售该技术。

3.商标:指用来区分企业的产品或服务与其他企业产品或服务的标识,如商标名称、商标图案等。

附件:本文档涉及的附件包括代码示例、示意图等。

数据结构实验8 查找与排序

数据结构实验8 查找与排序
查询菜单: (查找方法任选一种)
1.按学号查询
2.按姓名查询
3.按房号查询
打印任一查询结果(可以连续操作)。
参考:
typedef struct {
char sno[10];
char sname[2];
int sex; //以0表示女,1表示男
int roomno;
}ElemType;
struct SqList
注意事项:
在磁盘上创建一个目录,专门用于存储数据结构实验的程序。因为机房机器有还原卡,请同学们将文件夹建立在最后一个盘中,以学号为文件夹名。
实验八查找和排序
一、实验目的
掌握运用数据结构两种基本运算查找和排序,并能通过其能解决应用问题。
二、实验要求
1.掌握本实验的算法。
2.上机将本算法实现。
三Hale Waihona Puke 实验内容for(i=0;i<L.length;i++)
cout<<setw(7)<<L.elem[i].sno<<setw(10)<<L.elem[i].sname<<setw(3)<<L.elem[i].sex<<setw(6)<<L.elem[i].roomno<<endl;
}
为宿舍管理人员编写一个宿舍管理查询软件,程序采用交互工作方式,其流程如下:
建立数据文件,数据结构采用线性表,存储方式任选(建议用顺序存储结构),数据元素是结构类型(学号,姓名,性别,房号),元素的值可从键盘上输入,可以在程序中直接初始化。
数据文件按关键字(学号、姓名、房号)进行排序(排序方法任选一种),打印排序结果。(注意字符串的比较应该用strcmp(str1,str2)函数)

北京理工大学数据结构实验报告二__堆栈和队列

北京理工大学数据结构实验报告二__堆栈和队列

数据结构实验报告(二)实验二堆栈和队列一、实验目的和要求:1、掌握堆栈和队列的基本概念;2、掌握堆栈和队列的基本操作。

二、实验原理:1、堆栈的定义:堆栈是一种只允许在表的一端进行插入和删除运算的特殊的线性表。

允许进行插入和删除运算的一端称为栈顶,另一端称为栈底,当链表中没有元素时,称为空栈。

2、堆栈的插入运算称为入栈或者进栈,删除运算称为出栈或者退栈,栈顶的当前位置是动态的,标识栈顶当前位置的指针称为栈顶指针。

每次进栈的数据元素都放在原当前栈顶元素之前成为新的栈顶元素,每次退栈的数据元素都是原当前栈顶元素,最后进入堆栈的数据元素总是最先退出堆栈。

3、堆栈的存储结构:(1)顺序存储结构:栈的顺序存储结构称为顺序栈。

顺序栈的本质是顺序表的简化。

(2)链式存储结构:栈的链式存储结构称为链栈,通常用单链表示。

链栈的插入和删除操作只需处理栈顶的情况。

4、队列的定义:队列是允许在表的一端进行插入,而在表的另一端进行删除的特殊线性表。

允许进行插入的一端称为队尾,允许进行删除的一端称为队头。

队列的插入运算称为进队或者入队,删除运算称为出队或者离队,因此队列又称为先进先出表。

5、队列的存储结构队列的存储结构同线性表一样,可以分为顺序结构和链式结构。

(1)顺序存储结构:用顺序存储结构存储队列称为顺序队列。

顺序队列会出现假溢出问题,解决办法是用首尾相接的书顺序存储结构,称为循环队列。

在队列中,只要涉及队头或者队尾指针的修改都要对其求模。

(2)链式存储结构:用链式存储结构存储的队列称为链队列。

链队列的基本操作的实现基本上也是单链表操作的简化。

通常附设头结点,并设置队头指针指向头结点,队尾指针指向终端结点。

插入数据时只考虑在链队列的尾部进行,删除数据时只考虑在链队列的头部进行。

三、实验内容:1、试编写一个算法,建立一个学生成绩栈,要求从键盘上输入N个整数,按照下列要求分别进入不同的栈。

(1)若输入的整数X小于60,则进入第一个栈;(2)若输入的整数x大于等于60并小于100,则进入第二个栈;(3)若输入的整数x大于100,则进入第三个栈;(4)分别输出每个栈的内容。

北理工数据结构第三章实验报告

北理工数据结构第三章实验报告

北理工数据结构第三章实验报告第三章作业1、写出下列程序段的输出结果。

viod main ( ){ Stack S;char x, y;InitStack (S);x=’c’; y=’k’;Push(S, x); Push(S, ’a’); Push(S, y);Pop(S, x); Push(S, ’t’); Push(S, x);Pop(S, x); Push(S, ’s’);while ( ! StackEmpty(S) ){ Pop(S, y);printf (y);}printf(x);}stac k2、简述下列算法的功能(栈的元素类型SElemType为int)。

(1)Ststus algo1(Stack S){ int I, n, A[255];n=0;while ( ! StackEmpty(S) ){ n++; Pop(S, A[n]);}for ( i=1; i<=n; i++ )Push(S, A[n]);}将栈S中的元素以出栈的顺序排在数组中,且出栈的先后和数组的序号从小到大一致。

栈S变成空栈。

然后再从前到后输出数组中的数。

(2)Status algo2(Stack S, int e){ Stack T; int d;InitStack (T);while ( ! StackEmpty(S) ){ Pop(S, d);if ( d!=e ) Push(T, d);}while ( ! StackEmpty(T) ){ Pop (T, d);Push (S, d);}}将和e一致的数排到栈底,其他元素前后顺序保持不变。

3、设有4个元素1、2、3、4依次进栈,而出栈操作可随时进行(进出栈可任意交错进行,但要保证进栈次序不破坏1、2、3、4的相对次序),请写出所有可能的出栈次序。

可能次序:(1243)(1234)(1324)(1342)(1432)(2143)(2134)(2341)(2431)(2314)(3214)(3421)(3241)(4321)4、写出下列程序段的输出结果(队列中的元素类型QelemType 为char)。

北理工数据结构实验报告1

北理工数据结构实验报告1

《数据结构与算法设计》实验报告——实验一学院:自动化学院班级:__学号:__姓名:____ ____一、实验目的1、熟悉VC环境,学习使用C语言实现链表的存储结构。

2、通过编程、上机调试,进一步理解线性表、链表、环表的基本概念。

3、锻炼动手编程,独立思考的能力。

二、实验内容采用单向环表实现约瑟夫环。

请按以下要求编程实现:①从键盘输入整数m,通过create函数生成一个具有m个结点的单向环表。

环表中的结点编号依次为1,2,……,m。

②从键盘输入整数s(1<=s<=m)和n,从环表的第s个结点开始计数为1,当计数到第n个结点时,输出该第n结点对应的编号,将该结点从环表中消除,从输出结点的下一个结点开始重新计数到n,这样,不断进行计数,不断进行输出,直到输出了这个环表的全部结点为止。

例如,m=10,s=3,n=4。

则输出序列为:6,10,4,9,5,2,1,3,8,7。

三、程序设计1、概要设计为实现上述程序功能,应用单向环表寄存数字序列。

为此,需要单向环表的抽象数据结构。

(1)、单项环表的抽象数据类型定义为:ADT Joseph{数据对象:D={|,1,2,,,0}i i a a ElemSet i n n ∈=≥数据关系:R1=11{,|,,1,2,,}i i i i a a a a D i n --<>∈=基本操作:create(&J, n)操作结果:构造一个有n 个结点的单向环表J 。

show(J)初始条件:单向环表J 已存在。

操作结果:按顺序在屏幕上输出J 的数据元素。

calculate( J,s,n)初始条件:单向环表J 已存在,s>0,n>0,s<环表结点数。

操作结果:返回约瑟夫环的计算结果。

}ADT Joseph(2)、宏定义#define OK 1#define ERROR 0(3)、主程序流程主程序首先调用create(J,m)函数创建含有m 个结点的单向环表J ,随后调用show(J)函数显示创建的环表内容,最后调用calculate(J,s,n)函数计算结果并在屏幕上打印。

数据结构课程设计实验报告(各种排序的实现与效率分析)

数据结构课程设计实验报告(各种排序的实现与效率分析)

数据结构课程设计实验报告1、需求分析(1)对起泡排序、直接排序、简单选择排序、快速排序、希尔排序、堆排序算法进行比较;(2)待排序表的表长不小于100,表中数据随机产生,至少用5组不同数据作比较,比较指标有:关键字参加比较次数和关键字的移动次数(关键字进行一次交换操作记为3次移动);(3)输出比较结果。

2、主要函数及数据类型typedef int KeyType; //定义关键字类型为整数类型typedef int InfoType; //定义关键字类型为整数类型typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等*/typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */typedef struct{KeyType key; //关键字项InfoType otherinfo; //其它数据项}RedType; //记录类型typedef struct {RedType r[MAXSIZE+1]; //r[0]闲置或用作哨兵单元int length; //顺序表长度}SqList; //顺序表类型3、源代码/*头文件和宏定义部分*/#include"string.h"#include"ctype.h"#include"time.h"#include"malloc.h" /* malloc()等*/#include"limits.h" /* INT_MAX等*/#include"stdio.h" /* EOF(=^Z或F6),NULL */#include"stdlib.h" /* atoi() */#include"io.h" /* eof() */#include"math.h" /* floor(),ceil(),abs() */#include"process.h" /* exit() *//* 函数结果状态代码*/#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define MAXSIZE 100 //示例数据类型的最大长度typedef int KeyType; //定义关键字类型为整数类型typedef int InfoType; //定义关键字类型为整数类型typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等*/ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */typedef struct{KeyType key; //关键字项InfoType otherinfo; //其它数据项}RedType; //记录类型typedef struct {RedType r[MAXSIZE+1]; //r[0]闲置或用作哨兵单元int length; //顺序表长度}SqList; //顺序表类型void InitData(SqList *L,int dataCopy[]){int i;L->length=MAXSIZE;srand((unsigned)time(NULL));for(i=0;i<=MAXSIZE;i++){L->r[i].otherinfo=0;dataCopy[i]=L->r[i].key=rand();}}void PrintData(SqList L){int i;for(i=1;i<=L.length;i++){printf("%d\t",L.r[i].key);}}void ResumeData(SqList *L,int dataCopy[]){int i;for(i=0;i<=MAXSIZE;i++){L->r[i].key=dataCopy[i];}}void PrintStatistic(int *compareCounts,int *moveCounts){printf("\n\t\t各种排序方法比较结果:\n\n");printf("\t\t起泡排序: 比较次数%d,移动次数%d\n",compareCounts[0],moveCounts[0]);printf("\t\t直接插入排序:比较次数%d,移动次数%d\n",compareCounts[1],moveCounts[1]);printf("\t\t简单选择排序:比较次数%d,移动次数%d\n",compareCounts[2],moveCounts[2]);printf("\t\t快速排序: 比较次数%d,移动次数%d\n",compareCounts[3],moveCounts[3]);printf("\t\t希尔排序: 比较次数%d,移动次数%d\n",compareCounts[4],moveCounts[4]);printf("\t\t堆排序: 比较次数%d,移动次数%d\n",compareCounts[5],moveCounts[5]);}/*******************************直接插入排序*******************************/void InsertSort(SqList *L,int *compareCounts,int *moveCounts ) //直接插入排序{int i,j; //for(i=2;i<=L->length;i++) //从顺序表的第二个元素开始进行比较{if(L->r[i].key<L->r[i-1].key) //将每个元素与它的前一个元素关键字进行比较{L->r[0]=L->r[i]; //如果关键字比前一个元素关键字小,就将元素复制作为哨兵L->r[i]=L->r[i-1];(*moveCounts)+=2; //关键字移动了2次j=i-2; //从要比较的关键字的前第二个记录开始进行比较,然后后移while(L->r[0].key<L->r[j].key){L->r[j+1]=L->r[j]; //记录后移(*moveCounts)++; //每作一次后移,移动次数加1j--;(*compareCounts)++; //每作一次比较,比较次数加1}L->r[j+1]=L->r[0]; //插入到正确位置}(*compareCounts)++;}}/*******************************希尔排序*******************************/void ShellInsert(SqList *L,int increment,int *compareCounts,int *moveCounts){ //对顺序表作一趟希尔插入排序int j,n;for(j=1+increment;j<=L->length;j++){if(L->r[j].key<L->r[j-increment].key) //将L->[i]插入到有序增量子表{L->r[0]=L->r[j]; //暂存在L->r[0]L->r[j]=L->r[j-increment];(*moveCounts)+=2;for(n=j-2*increment;n>0&&L->r[0].key<L->r[n].key;n-=increment){L->r[n+increment]=L->r[n]; //记录后移,查找插入位置(*moveCounts)++;(*compareCounts)++;}L->r[n+increment]=L->r[0]; //插入(*moveCounts)++;}(*compareCounts)++;}}void ShellSort(SqList *L,int IncreList[],int times,int *compareCounts,int *moveCounts) //希尔排序{ //按增量序列Increlist[0.....times-1]对顺序表L作希尔排序int k; //for(k=0;k<times;k++){ShellInsert(L,IncreList[k],compareCounts,moveCounts); //一趟增量为IncreList[k]的插入排序}}/*******************************起泡排序*******************************/void BubbleSort(SqList *L,int *compareCounts,int *moveCounts) //起泡排序{int i,j;for(i=1;i<=L->length;i++){for(j=L->length;j>i;j--){ //从后往前两两进行比较,将元素关键字小的交换到前面if(L->r[j].key<L->r[j-1].key){L->r[0]=L->r[j];L->r[j]=L->r[j-1];L->r[j-1]=L->r[0];(*moveCounts)+=3;}(*compareCounts)++;}}}/*******************************快速排序*******************************/int Partition(SqList *L,int low,int high,int *compareCounts,int *moveCounts) //快速排序中的分{int pivotkey;L->r[0]=L->r[low];(*moveCounts)++;pivotkey=L->r[low].key;while(low<high){while(low<high&&L->r[high].key>=pivotkey){high--;(*compareCounts)++;}L->r[low]=L->r[high];(*moveCounts)++;while(low<high&&L->r[low].key<=pivotkey){low++;(*compareCounts)++;}L->r[high]=L->r[low];(*moveCounts)++;(*compareCounts)++;}L->r[low]=L->r[0];(*moveCounts)++;return low;}void QSort(SqList *L,int low,int high,int *compareCounts,int *moveCounts){int pivotloc;if(low<high){pivotloc=Partition(L,low,high,compareCounts,moveCounts);QSort(L,low,pivotloc-1,compareCounts,moveCounts);QSort(L,pivotloc+1,high,compareCounts,moveCounts);}}void QuickSort(SqList *L,int *compareCounts,int *moveCounts){QSort(L,1,L->length,compareCounts,moveCounts);}/*******************************简单选择排序*******************************/void SelectSort(SqList *L,int *compareCounts,int *moveCounts){int i,j,minPoint;for(i=1;i<=L->length;i++){L->r[0]=L->r[i];(*moveCounts)++;minPoint=i;for(j=i+1;j<=L->length;j++){if(L->r[j].key<L->r[0].key){L->r[0]=L->r[j];(*moveCounts)++;minPoint=j;}(*compareCounts)++;}L->r[minPoint]=L->r[i];L->r[i]=L->r[0];(*moveCounts)++;}}/*******************************堆排序*******************************/void HeapAdjust(SqList *L,int s,int m,int *compareCounts,int *moveCounts){RedType cmpKey; //待比较的值int j;cmpKey=L->r[s];(*moveCounts)++;for(j=s*2;j<=m;j*=2){(*compareCounts)+=2;if(j<m&&L->r[j].key<L->r[j+1].key) j++;if(!(cmpKey.key<L->r[j].key)) break;L->r[s]=L->r[j];(*moveCounts)++;s=j;}L->r[s]=cmpKey;(*moveCounts)++;}void HeapSort(SqList *L,int *compareCounts,int *moveCounts){int i;RedType temp;for(i=L->length/2;i>0;i--) HeapAdjust(L,i,L->length,compareCounts,moveCounts);for(i=L->length;i>1;i--){temp=L->r[1];L->r[1]=L->r[i];L->r[i]=temp;(*moveCounts)+=3;HeapAdjust(L,1,i-1,compareCounts,moveCounts);}}void SortCompare(){SqList L; //用顺序表存放待排序的元素int dataCopy[MAXSIZE+1],i;int compareCounts[7],moveCounts[7];int increList[6];for(i=0;i<5;i++){increList[i]=(int)pow(2,7-i)-1;}increList[5]=1;for(i=0;i<7;i++){compareCounts[i]=0;moveCounts[i]=0;}InitData(&L,dataCopy); //初始化数据,随机产生100个正整数的数列printf("\t\t\t初始化数据后产生的数列:\n");PrintData(L); //显示出未排序的数列printf("\n\n\t\t\t经过起泡排序后产生的数列:\n");BubbleSort(&L,&compareCounts[0],&moveCounts[0]); //对数列使用起泡排序PrintData(L); //显示出排序好的数列ResumeData(&L,dataCopy);printf("\n\n\t\t\t经过直接插入排序后产生的数列:\n");InsertSort(&L,&compareCounts[1],&moveCounts[1]); //对数列使用插入排序PrintData(L); //显示出排序好的数列ResumeData(&L,dataCopy);printf("\n\n\t\t\t经过简单选择排序后产生的数列:\n");SelectSort(&L,&compareCounts[2],&moveCounts[2]); //对数列使用简单选择排序PrintData(L); //显示出排序好的数列ResumeData(&L,dataCopy);printf("\n\n\t\t\t经过快速排序后产生的数列:\n");QuickSort(&L,&compareCounts[3],&moveCounts[3]); //对数列使用快速排序PrintData(L); //显示出排序好的数列ResumeData(&L,dataCopy);printf("\n\n\t\t\t经过希尔排序后产生的数列:\n");ShellSort(&L,increList,6,&compareCounts[4],&moveCounts[4]); //对数列使用希尔排序PrintData(L); //显示出排序好的数列ResumeData(&L,dataCopy);printf("\n\n\t\t\t经过堆排序后产生的数列:\n");HeapSort(&L,&compareCounts[5],&moveCounts[5]); //对数列使用堆排序PrintData(L); //显示出排序好的数列PrintStatistic(compareCounts,moveCounts);}main(){int i,temp;for(i=0;i<5;i++){SortCompare();printf("\n\t\t请按任意键进行下一组数据的排序对比\n\n");temp=getchar();}}4、调试分析成功运行,如图所示:。

北京理工大学数据结构作业(全)

北京理工大学数据结构作业(全)

北京理工大学数据结构作业(全)北理工数据结构作业第二章作业1、在什么情况下用顺序表比链表好?(题集2.3)需要对线性表进行随机存取时,顺序表比链表好。

2、已知L是带表头结点的非空单链表,且P结点既不是首元结点,也不是尾元结点,试从下列提供的答案中选择合适的语句序列。

(题集2.7)a.删除P结点的直接后继结点的语句序列是11 3 14。

b.删除P结点的直接前驱结点的语句序列是10 12 8 3 14。

c.删除P结点的语句序列是10 12 7 3 14。

d.删除首元结点的语句序列是12 11 3 14。

e.删除尾元结点的语句序列是12 11 3 14。

(1)p = p->next;(2)p->next = p;(3)p->next = p->next->next;(4)p = p->next->next;(5)while ( p!=NULL ) p=p->next;(6)while ( q->next!=NULL ) { p=q; q=q->next; }(7)while ( p->next!=q ) p=p->next;(8)while ( p->next->next!=q ) p=p->next;(9)while ( p->next->next!=NULL ) p=p->next;(10)q=p;(11)q=p->next;(12)p=l;(13)l=l->next;(14)free(q);3、算法设计。

设顺序表va中的数据元素递增有序,请设计一算法,将x插入到顺序表的适当位置,以保持该表的有序性。

(题集2.11)typedef struct{ElemType *elem;int length;int listsize;}Sqlist;Status ListInsert_Sq(Sqlist &va , ElemType x){if(va.length==va.listsize) return ERROR;for(i=va.length-1;i>=0&&xva.elem[i+1]=x;va.length++;return OK;}4、算法设计。

数据结构排序实验报告

数据结构排序实验报告

数据结构排序实验报告一、实验目的本次数据结构排序实验的主要目的是深入理解和掌握常见的排序算法,包括冒泡排序、插入排序、选择排序、快速排序和归并排序,并通过实际编程和实验分析,比较它们在不同规模数据下的性能表现,从而为实际应用中选择合适的排序算法提供依据。

二、实验环境本次实验使用的编程语言为 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 个元素)的随机整数列表作为测试数据。

北理工数据结构实验报告2

北理工数据结构实验报告2

《数据结构与算法设计》实验报告——实验二学院:自动化学院班级:____学号:__姓名:_____一、实验目的1、熟悉VC 环境,学习使用C 语言实现栈的存储结构。

2、通过编程、上机调试,进一步理解栈的基本概念。

3、锻炼动手编程,独立思考的能力。

二、实验内容实现简单计算器的功能,请按照四则运算加、减、乘、除、幂(^)和括号的优先关系和惯例,编写计算器程序。

要求支持运算符:+、-、*、/、%、()和=:① 从键盘输入一个完整的表达式,以回车作为表达式输入结束的标志;② 输入表达式中的数值均为大于等于零的整数,如果中间计算过程中出现小数也只取整进行计算。

例如,输入:4+2*5= 输出:14 输入:(4+2)*(2-10)= 输出:-48 三、程序设计 1、概要设计为实现上述程序功能,应使用两个栈,分别寄存操作数与运算符。

为此,需要栈的抽象数据结构。

(1)、栈的抽象数据类型定义为: ADT Stack{数据对象:D={|,1,2,,,0}i i a a ElemSet i n n ∈=≥数据关系:R1=11{,|,,2,,}i i i i a a a a D i n --<>∈=约定n a端为栈顶,1a端为栈底。

基本操作:InitStack(&S)操作结果:创建一个空栈S。

GetTop(S,&e)初始条件:栈S已存在且非空。

操作结果:用e返回S的栈顶元素。

Push(&S,e)初始条件:栈S已存在。

操作结果:插入元素e为新的栈顶元素。

Pop(&S,&e)初始条件:栈S已存在且非空。

操作结果:删除S的栈顶元素,并用e返回其值。

In(m,a[])操作结果:若m是运算符,返回TRUE。

Precede(m, n)初始条件:m,n为运算符。

操作结果:若m优先级大于n,返回>,反之亦然。

Operation(a, theta,b)初始条件:a,b为整数,theta为运算符。

北理工数据结构实验四

北理工数据结构实验四

对全部高中资料试卷电气设备,在安装过程中以及安装结束后进行高中资料试卷调整试验;通电检查所有设备高中资料电试力卷保相护互装作置用调与试相技互术关,系电,通力根1保过据护管生高线产中敷工资设艺料技高试术中卷0资不配料仅置试可技卷以术要解是求决指,吊机对顶组电层在气配进设置行备不继进规电行范保空高护载中高与资中带料资负试料荷卷试下问卷高题总中2体2资,配料而置试且时卷可,调保需控障要试各在验类最;管大对路限设习度备题内进到来行位确调。保整在机使管组其路高在敷中正设资常过料工程试况1卷中下安,与全要过,加度并强工且看作尽护下可1都关能可于地以管缩正路小常高故工中障作资高;料中对试资于卷料继连试电接卷保管破护口坏进处范行理围整高,核中或对资者定料对值试某,卷些审弯异核扁常与度高校固中对定资图盒料纸位试,置卷编.工保写况护复进层杂行防设自腐备动跨与处接装理地置,线高尤弯中其曲资要半料避径试免标卷错高调误等试高,方中要案资求,料技编试术写5、卷交重电保底要气护。设设装管备备置线4高、调动敷中电试作设资气高,技料课中并3术试、件资且中卷管中料拒包试路调试绝含验敷试卷动线方设技作槽案技术,、以术来管及避架系免等统不多启必项动要方高式案中,;资为对料解整试决套卷高启突中动然语过停文程机电中。气高因课中此件资,中料电管试力壁卷高薄电中、气资接设料口备试不进卷严行保等调护问试装题工置,作调合并试理且技利进术用行,管过要线关求敷运电设行力技高保术中护。资装线料置缆试做敷卷到设技准原术确则指灵:导活在。。分对对线于于盒调差处试动,过保当程护不中装同高置电中高压资中回料资路试料交卷试叉技卷时术调,问试应题技采,术用作是金为指属调发隔试电板人机进员一行,变隔需压开要器处在组理事在;前发同掌生一握内线图部槽 纸故内资障,料时强、,电设需回备要路制进须造行同厂外时家部切出电断具源习高高题中中电资资源料料,试试线卷卷缆试切敷验除设报从完告而毕与采,相用要关高进技中行术资检资料查料试和,卷检并主测且要处了保理解护。现装场置设。备高中资料试卷布置情况与有关高中资料试卷电气系统接线等情况,然后根据规范与规程规定,制定设备调试高中资料试卷方案。
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

本科实验报告实验名称:排序
一、实验目的
2、通过编程、上机调试,进一步理解排序的方法。

3、具体尝试插入排序、快速排序、选择排序的操作步骤。

4、锻炼动手编程,独立思考的能力。

二、实验题目
排序
输入10个数,从插入排序、快速排序、选择排序三类算法中各选一种编程实现
三、实验基础知识
插入排序、快速排序、选择排序三类算法的基本思想
四、实验设计方法
1、概要设计
(1)、插入排序(此次使用直接插入排序)
void InsertionSort ( SqList &L )
{ // 对顺序表L 作直接插入排序。

for ( i=2; i<=L.length; ++i )
if (L.r[i].key < L.r[i-1].key)
{
L.r[0] = L.r[i]; // 复制为监视哨
for ( j=i-1; L.r[0].key < L.r[j].key; -- j )
L.r[j+1] = L.r[j]; // 记录后移
L.r[j+1] = L.r[0]; // 插入到正确位置
}
} // InsertSort
(2)、快速排序(此次用的是起泡排序)
V oid Bubblesort(elem R[],int n)
{
I=n;
While(i>1){
lastExchangeIndex = 1;
for(j=1;j<i;j++)
if(R[j+1].key<R[j].key){
swap(R[j],R[j+1]);
lastExchangeIndex =j; //记下进行交换的记录位置}
I=lastExchangeIndex ; //本趟进行过交换的最后一个记录的位置
}//Bubblesort
(3)、选择排序
V oid selectsort(elem r[],int n)
{
//对记录序列r[1..n]作简单选择排序。

for(i=1;i<n;++i){//选择第i小的记录,并交换到位
j=selectminkey(r,i);
//zai r[i..n]中选择关键字最小的记录
if(i!=j) R[i] R[j];
//与第i个记录交换
}
}//selectsort
五、实验结果及数据分析
数据为3 2 4 1 5 0 6 9 8 7的十个数的三种排序方法
1、插入排序
2、快速排序
3、选择排序
六、总结
此次编程实验,较前几次而言稍微简单一点,并且以前用过起泡排序法,所以对排序方面比较熟悉,但是也遇到了一些问题,例如数组下标问题没处理好,让我在编程实践中花费了大量时间检查。

七、附录程序清单
1、插入排序(直接插入排序)
#include<stdio.h>
int main()
{
printf("插入排序\n");
int i ,n,k, j,a[10], b[10];
for(i=0;i<10;i++)
{
scanf("%d",&a[i]);
}
b[0]=a[0];
for(i=1;i<10;i++)
{
n=a[i]; //选择一个数插入for(j=0;j<i&&n>b[j];j++); //找到插入位置
for(k=8;k>=j;k--) //将插入位置后的数全部后移一位
b[k+1]=b[k];
b[j]=n; //赋值
}
for(i=0;i<10;i++)
printf("%d ",b[i]); //输出
}
2、快速排序(起泡排序)
#include<stdio.h>??
int main()
{
printf("快速排序\n");
int i,j,temp,a[10];
for(i=0;i<10;i++)
scanf("%d",&a[i]);
for(i=0;i<10;i++) //进行十次大循环
{
for(j=0;j<10-i;j++) //每次小循环排列一个数
{
if(a[j]>a[j+1]) //将数较大的和数较小的互换位置
{
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}}}
for(i=0;i<10;i++)
printf("%d ",a[i]); //输出
return 0;
}
3、选择排序(简单选择排序)
#include<stdio.h>
int main()
{
int a[10],i,j,k,temp;
for(i=0;i<10;i++)
scanf("%d",&a[i]);
for ( i=0 ; i<9; i++) //n-1趟排序
{
k=i;
for(j=i+1;j<10;j++) //查找最小记录的位置
if (a[j]<a[k])
k=j;
if(k!=i) //若无序区第一个元素不是无序区中最小元素,则进行交换
{
temp= a[i];
a[i]= a[k];
a[k]=temp;
}
}
for(i=0;i<10;i++)
printf("%d ",a[i]); return 0;
}。

相关文档
最新文档