数据结构实验二资料
数据结构实验报告 (2)
数据结构实验报告实验报告数据结构实验报告应包含以下几个部分:1. 实验目的:简要介绍实验的目的和意义。
2. 原理介绍:详细介绍本次实验所涉及的数据结构原理,包括数据结构的定义、特性以及相关算法或操作。
3. 实验内容:详细描述本次实验的具体内容,包括实验要求和实验步骤。
4. 实验结果:展示实验的结果,以适当的方式呈现实验数据和实验输出。
可以包括图表、表格、代码等。
5. 分析讨论:分析实验结果,讨论实验结果与预期结果的差异,并给出相应的解释。
6. 实验总结:对本次实验的总结和评价,包括实验的收获、不足之处以及改进的建议。
以下是一个简单的数据结构实验报告的范例:实验目的:本次实验的目的是熟悉链表数据结构的概念和基本操作,包括链表的插入、删除和查找等。
原理介绍:链表是一种常用的数据结构,它由一组节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。
链表中的节点可以通过指针相互连接,从而形成一串有序的数据。
链表不同于数组,它的插入和删除操作十分高效,但查找效率较低。
实验内容:本次实验要求实现一个链表,并在链表中实现插入、删除和查找操作。
首先,定义一个节点结构,并实现节点的插入和删除操作;其次,实现查找操作,并根据查找结果返回节点位置或者相关信息。
实验结果:经过实验,我们得到了以下结果:在链表中插入节点的时间复杂度为O(1),删除节点的时间复杂度为O(1),查找节点的时间复杂度为O(n)。
分析讨论:从结果可以看出,链表的插入和删除操作的效率较高,但查找操作的效率较低。
这是因为链表中的节点没有连续的存储空间,所以需要遍历整个链表才能找到目标节点。
如果需要频繁进行查找操作,可以考虑使用其他数据结构,如二叉搜索树或哈希表。
实验总结:通过本次实验,我们深入了解了链表数据结构的原理和基本操作,并实现了一个简单的链表。
在以后的学习和实践中,我们可以根据实际需求选择合适的数据结构,以提高程序的效率和性能。
此外,本次实验也让我们更加熟悉了编程的过程和技巧。
数据结构实验2报告总结
一实验目的和要求理解二叉树的基本概念,熟练使用多种表示法构造二叉树,掌握采用二叉链表存储结构实现二叉树的构造、遍历、插入、删除等操作算法;理解线索二叉树的作用,掌握获得线索二叉树节点在指定遍历次序下的前驱或后继结点的方法;理解哈弗曼编码和哈弗曼树的作用,掌握由指定文本求得哈弗曼编码的方法。
理解树的基本概念,熟悉树的多种存储结构,掌握采用孩子兄弟链表存储结构实现树的遍历、插入、删除等操作算法。
通过研究树和二叉树,深刻理解链式存储结构用于表达非线性结构的作用,掌握采用递归算法实现递归数据结构基本操作的设计方法。
二题目及题意分析题目:插入x元素作为p结点的第i个孩子分析:以中国城市作为元素,以插入孩子结点的方式构造一棵树,找到结点p,p不为空时,若p的孩子结点为空,则直接插入x元素作为p的孩子;若p的孩子结点不为空,插入的x元素的位置n小于等于1时,将x元素直接插在最前面;若n大于1时,查找插入的位置执行插入。
三设计方案和功能说明源程序如下:TreeNode.htemplate<class T>class TreeNode //数的孩子兄弟链表结点类{public: //数据域,保存元素T data;TreeNode<T>* child,*sibling; //指针域,分别指向孩子兄弟结点TreeNode<T>(T data,TreeNode<T>*child=NULL,TreeNode<T>*sibling=NULL){this->data=data;this->child=child;this->sibling=sibling;}};Tree.h#include<iostream.h>#include"TreeNode.h" //树的孩子兄弟链表节点类template<class T>class Tree //树类{public:TreeNode<T>*root; //指向根结点Tree(); //构造空树bool isEmpty();//判断是否空树TreeNode<T>* insertChild(TreeNode<T>*p,T value); // 插入value作为结点p的孩子TreeNode<T>* insertChild(TreeNode<T>*p,T x,int i);// 插入x元素作为p结点的第i 个孩子friend ostream&operator<<(ostream&out,Tree<T>&tree);//先根次序遍历树并以树的横向凹入表示法输出树void preOrder(TreeNode<T> *p,int i);};template<class T>Tree<T>::Tree() //构造空树{root=NULL;}template<class T>bool Tree<T>::isEmpty()//判断是否空树{return root==NULL;}template<class T>TreeNode<T>* Tree<T>::insertChild(TreeNode<T>*p,T value) //插入value作为结点p的孩子{TreeNode<T>*q=NULL;if(p!=NULL){q=new TreeNode<T> (value);if(p->child==NULL)p->child=q;else{p=p->child;while(p->sibling!=NULL)p=p->sibling;p->sibling=q;}}return q;}template<class T>TreeNode<T>*Tree<T>::insertChild(TreeNode<T>* p,T x,int i)// 插入x元素作为p结点的第i 个孩子{TreeNode<T>*q=NULL;if(p!=NULL){q=new TreeNode<T>(x);if(p->child==NULL)p->child=q;else{{if(i<=1)//带有容错功能{p->child=new TreeNode<T>(x,NULL,p->child);return p->child;}p=p->child;for(int j=1;p->sibling!=NULL&&j<i-1;j++)p=p->sibling;if( p->sibling==NULL)p->sibling=q;elsep->sibling=new TreeNode<T>(x,NULL,p->sibling);}}}return q;}template<class T>void Tree<T>::preOrder(TreeNode<T> *p,int i){if(p!=NULL){for(int j=0;j<i;j++)cout<<"\t";cout<<p->data<<endl;preOrder(p->child,i+1);preOrder(p->sibling,i);}}template<class T>ostream&operator<<(ostream&out,Tree<T> &tree)//先根次序遍历树并以树的横向凹入表示法输出树{tree.preOrder(tree.root,0);return out;}Main.cpp#include "Tree.h"TreeNode<char*>*aa;void make(Tree<char*>&tree){tree.root=new TreeNode<char*>("中国");tree.insertChild(tree.root,"北京");tree.insertChild(tree.root,"上海");TreeNode<char*>*js=tree.insertChild(tree.root,"江苏省");tree.insertChild(js,"南京市");tree.insertChild(js,"苏州市");TreeNode<char*> *zj=tree.insertChild(tree.root,"浙江省");tree.insertChild(zj,"杭州市");tree.insertChild(zj,"宁波市");TreeNode<char*> *sx=tree.insertChild(tree.root,"山西省");tree.insertChild(sx,"太原市");tree.insertChild(sx,"大同市");aa=zj;}int main(){Tree<char*>tree;make(tree);cout<<tree;tree.insertChild(aa,"无锡市",2);cout<<tree;return 0;}四运行结果及分析1插入位置小于等于1(即n<=1)n=-2时n=0时n=1时2插入位置大于1(即n>1)n=2时五实验总结通过实验理解了树及二叉树的存储结构熟悉掌握了孩子兄弟链表的存储结构实现,以及遍历、查找、删除等操作,深刻理解实现链式存储结构表达非线性的树存储结构。
数据结构实验报告2
数据结构实验报告2数据结构实验报告21、实验目的本次实验的目的是通过使用数据结构来解决一个特定的问题。
具体而言,我们将会使用某种数据结构(例如链表、堆栈、队列等)来实现一个特定功能,并对其性能进行评估。
2、实验背景在本次实验中,我们将会探索数据结构在解决实际问题中的应用。
数据结构是计算机科学的重要组成部分,它提供了一种组织和管理数据的方式,以便能够高效地访问和操作这些数据。
3、实验内容在本次实验中,我们选择了一种经典的数据结构,以实现一个特定的功能。
具体而言,我们将会使用链表来实现一个简单的联系人管理系统。
3.1 数据结构选择我们选择了链表作为联系人管理系统的数据结构。
链表是一种灵活的数据结构,它能够动态地增加或删除元素,并且支持高效的插入和删除操作。
3.2 实现功能我们的联系人管理系统将会具有以下功能:- 添加联系人:用户可以输入联系人的姓名、方式号码等信息,并将其添加到联系人列表中。
- 删除联系人:用户可以选择要删除的联系人,并从列表中删除该联系人。
- 查找联系人:用户可以根据姓名或方式号码来查找联系人,并显示相关信息。
- 显示所有联系人:系统将会将所有联系人按照姓名的字母顺序进行排序,并将其显示在屏幕上。
4、实验步骤下面是本次实验的具体步骤:4.1 初始化联系人管理系统在系统开始之前,我们需要初始化联系人管理系统。
这包括创建一个空的联系人列表,并提供用户菜单来选择相应功能。
4.2 添加联系人用户可以选择添加联系人的功能,并输入联系人的相关信息。
系统将会将联系人添加到联系人列表中。
4.3 删除联系人用户可以选择删除联系人的功能,并输入要删除联系人的姓名或方式号码。
系统将会在联系人列表中查找并删除相应联系人。
4.4 查找联系人用户可以选择查找联系人的功能,并输入要查找联系人的姓名或方式号码。
系统将会在联系人列表中查找相应联系人,并显示其相关信息。
4.5 显示所有联系人用户可以选择显示所有联系人的功能。
数据结构实验报告2
数据结构实验报告2一、实验目的本次数据结构实验旨在通过实际操作和编程实践,深入理解和掌握常见的数据结构,如链表、栈、队列、树等,并能够运用所学知识解决实际问题,提高编程能力和算法设计能力。
二、实验环境本次实验使用的编程语言为C++,开发环境为Visual Studio 2019。
三、实验内容(一)链表的实现与操作1、单向链表的创建首先,定义了链表节点的结构体,包含数据域和指向下一个节点的指针域。
然后,通过函数实现了单向链表的创建,从用户输入获取节点的数据,依次创建新节点并连接起来。
2、链表的遍历编写函数实现对单向链表的遍历,依次输出每个节点的数据。
3、链表的插入与删除实现了在指定位置插入节点和删除指定节点的功能。
插入操作时,需要找到插入位置的前一个节点,修改指针完成插入。
删除操作时,同样找到要删除节点的前一个节点,修改指针并释放删除节点的内存。
(二)栈的实现与应用1、栈的基本操作使用数组实现了栈的数据结构,包括入栈、出栈、判断栈空和获取栈顶元素等操作。
2、表达式求值利用栈来实现表达式求值的功能。
将表达式中的数字和运算符分别入栈,按照运算规则进行计算。
(三)队列的实现与应用1、队列的基本操作使用循环数组实现了队列,包括入队、出队、判断队空和队满等操作。
2、模拟银行排队系统通过创建队列来模拟银行客户的排队情况,实现客户的入队和出队操作,统计平均等待时间等。
(四)二叉树的遍历1、二叉树的创建采用递归的方式创建二叉树,用户输入节点数据,构建二叉树的结构。
2、先序、中序和后序遍历分别实现了二叉树的先序遍历、中序遍历和后序遍历,并输出遍历结果。
四、实验结果与分析(一)链表实验结果成功创建、遍历、插入和删除单向链表。
通过对链表的操作,深入理解了链表的动态存储特性和指针的运用。
在插入和删除操作中,能够正确处理指针的修改和内存的释放,避免了内存泄漏和指针错误。
(二)栈实验结果栈的基本操作运行正常,能够正确实现入栈、出栈等功能。
数据结构实验二
数据结构实验二数据结构实验二:线性表的顺序存储结构实现一、实验目的本实验旨在通过实践,掌握线性表的顺序存储结构实现方法,加深对数据结构中线性表概念的理解,以及顺序存储结构的特点和操作。
二、实验内容1. 了解线性表的顺序存储结构的定义和特点;2. 设计并实现线性表的顺序存储结构的初始化操作;3. 设计并实现线性表的顺序存储结构的插入操作;4. 设计并实现线性表的顺序存储结构的删除操作;5. 设计并实现线性表的顺序存储结构的查找操作;6. 设计并实现线性表的顺序存储结构的修改操作;7. 设计并实现线性表的顺序存储结构的打印操作;8. 编写测试用例,验证线性表的顺序存储结构的各项操作是否正确。
三、实验步骤1. 定义线性表的顺序存储结构,包括表头指针、表长度和表最大容量等成员变量;2. 实现线性表的顺序存储结构的初始化操作,包括动态分配内存空间、初始化表头指针、表长度和表最大容量等;3. 实现线性表的顺序存储结构的插入操作,包括判断插入位置的合法性、移动元素、插入新元素等;4. 实现线性表的顺序存储结构的删除操作,包括判断删除位置的合法性、移动元素、修改表长度等;5. 实现线性表的顺序存储结构的查找操作,包括按值查找和按位置查找两种方式;6. 实现线性表的顺序存储结构的修改操作,包括判断修改位置的合法性、修改元素值等;7. 实现线性表的顺序存储结构的打印操作,按照从头到尾的顺序输出线性表中的元素;8. 编写测试用例,包括插入、删除、查找、修改和打印等操作的测试,验证线性表的顺序存储结构的正确性。
四、实验结果经过测试,线性表的顺序存储结构实现了初始化、插入、删除、查找、修改和打印等操作,并且各项操作的结果与预期一致。
五、实验总结通过本次实验,我深入理解了线性表的顺序存储结构的实现原理和操作方法。
顺序存储结构具有随机访问的优点,但插入和删除操作需要移动大量元素,效率较低。
在实际应用中,需要根据具体场景选择合适的存储结构。
数据结构实验二
实验二(2015-9-17)一、实验名称:复杂形式的对象。
二、实验目的:(1)掌握对象数组、对象指针的使用方法;(2)掌握对象数组、对象指针和对象引用作为函数参数的使用方法;(3)掌握类对象作为成员的使用方法;(4)掌握友元的概率和使用方法;(5)掌握静态数据成员和静态成员函数的使用方法;(6)进一步了解C++面向对象程序设计的基本思想、基本方法和基本步骤;三、练习项目1.Time类的框架定义如下:class Time //声明Time类{public:Time( int = 0, int = 0, int = 0 ); // 带默认参数的构造函数// set functionsvoid setTime( int, int, int ); // 设置hour, minute, secondvoid setHour( int ); // 设置hour (确保数据在合理范围)void setMinute( int ); // 设置minute (确保数据在合理范围)void setSecond( int ); // 设置second (确保数据在合理范围)// get functionsint getHour(); // 返回hourint getMinute(); // 返回minuteint getSecond(); // 返回secondvoid printUniversal(); // 按24小时格式输出时间:23:56:12void printStandard(); // 按12小时格式输出时间:11:56:12 (PM) 或9:23:55(AM) private:int hour; // 0 - 23 (24小时格式)int minute; // 0 - 59int second; // 0 - 59}; // Timel类定义结束(1)按照注释的要求完成所有成员函数的定义;(2)在主程序中定义Time类对象,通过对象指针或引用调用上述成员函数以测试其正确性。
数据结构实验二_栈的基本操作
青岛理工大学课程实验报告及实验步骤只要X不为0重复做下列动作将X%R入栈X=X/R只要栈不为空重复做下列动作栈顶出栈输出栈顶元素调试过程及实验结果根据输入的十进制数通过桟的基本操作可以转换成二进制、八进制、十六进制的数。
在上机过程中程序的调用没有太大的问题,按照课本的基本算法就可以将程序正确的运行。
总结程序可以完成基本的功能,可以将十进制数转换为其他进制的数,基本掌握了桟的几种常用的操作;但程序存在缺陷,就是不能持续进行操作,输入了一个十进制数只能进行一次数制转换,程序就会退出,有待改进。
附录#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define stack_init_size 100#define stackincrement 10typedef struct sqstack{int *base;int *top;int stacksize;} sqstack;int StackInit(sqstack *s){s->base=(int *)malloc(stack_init_size *sizeof(int));if(!s->base)return 0;{return 0;}}int conversion(sqstack *s){int n,e=0,flag=0;printf("输入要转化的十进制数:\n");scanf("%d",&n);printf("要转化为多少进制:2进制、8进制、16进制填数字!\n");scanf("%d",&flag);printf("将十进制数%d转化为%d进制是:\n",n,flag);while(n){s->top=s->base;s->stacksize=stack_init_size;return 1;}int Push(sqstack *s,int e){if(s->top-s->base>=s->stacksize){s->base=(int*)realloc(s->base,(s->stacksize+stackincrement)*sizeof(int)); if(!s->base)return 0;s->top=s->base+s->stacksize;s->stacksize+=stackincrement;}*(s->top++)=e;return e;}int Pop(sqstack *s,int e){if(s->top==s->base)return 0;e=*--s->top;return e;}int stackempty(sqstack *s){if(s->top==s->base){return 1;}elsePush(s,n%flag);n=n/flag;}while(!stackempty(s)) {e=Pop(s,e);switch(e){case 10: printf("A");break;case 11: printf("B");break;case 12: printf("C");break;case 13: printf("D");break;case 14: printf("E");break;case 15: printf("F");break;default: printf("%d",e); }}printf("\n");return 0;}int main(){sqstack s;StackInit(&s); conversion(&s);return 0;}。
数据结构实验报告2
数据结构实验报告2广东金融学院实验报告课程名称:数据结构实验编号 及实验名称实验二:排序和查找实验 系 别计算机科学与技术系姓 名 学 号 班 级 实验地点 实验日期 实验时数 6 指导教师同组其他成员无成 绩一、实验目的及要求1、 通过编写和调用直接插入排序、希尔排序、冒泡排序和快速排序四种排序算法实现数据排序,充分理解各种排序算法的算法思想、排序过程及各自的时间复杂度、稳定性。
2、 通过编写和调用顺序查找和二分查找算法实现数据查找,掌握两个查找算法的基本思想、实现方法和时间性能。
二、实验环境及相关情况(包含使用软件、实验设备、主要仪器及材料等)1、实验设备:微型计算机;2、软件系统:Windows XP 、DWMX 。
装订○○○○三、实验内容(一)排序(1)参照课本,分别编写Java程序,实现顺序表记录类RecordNode、类KeyType。
(2)参照课本,编写一个Java程序,实现顺序表类SeqList,并在其中添加成员函数:length()求顺序表的当前长度;display()输出数组元素的关键字;直接插入排序算法;带监视哨的直接插入排序;希尔排序算法;起泡排序算法;快速排序算法。
(3)编写主程序,循环选择调用以上5个排序算法,对数组元素排序,并输出排序过程。
(二)查找(1)在排序实验的基础上,在类SeqList中添加成员函数:不带监视哨的顺序查找算法;带监视哨的顺序查找算法;二分查找算法。
(2)编写主程序,循环选择调用以上3个查找算法,分别对键入的关键字记录进行成功和不成功查找public class KeyType implements Comparable<KeyType>{private int key;public KeyType(){}public KeyType(int key){this.key=key;}public int getKey(){return key;}public void setKey(int key){this.key=key;}public String toString(){return key +"";}public int compareTo(KeyType another){int thisVal=this.key;int anotherVal=another.key;return(thisVal<anotherVal? -1:(thisVal==anotherVal? 0:1));}}public class RecordNode{private Comparable key;private Object element;public Object getElement(){return element;}public void setElement(Object element){this.element=element;}public C omparable getKey(){r[j]=r[j-1];}r[i]=x;this.curlen++;}public void insertSort(){ //直接插入RecordNode temp;int i,j;for(i=1;i<this.curlen;i++){temp=r[i];for(j=i-1;j>=0&&temp.getKey().compareTo(r[j].getKey())<0;j--){r[j+1]=r[j];}r[j+1]=temp;}}public void shellSort(int[]d){ //希尔RecordNode temp;int i,j;for(int k=0;k<d.length;k++){int dk=d[k];for(i=dk;i<this.curlen;i++){temp=r[i];for(j=i-dk;j>=0&&temp.getKey().compareTo(r[j].getKey())<0;j-=dk){ r[j+dk]=temp;}}}}public void insertSortWithGuard(){ //带监视哨的直接插入int i,j;for(i=1;i<this.curlen;i++){r[0]=r[i];for(j=i-1;r[0].getKey().compareTo(r[j].getKey())<0;j--){r[j+1]=r[j];}r[j+1]=r[0];}}public void bubbleSort(){ //冒泡RecordNode temp;boolean flag=true;for(int i=1;i<this.curlen&&flag;i++){flag=false;for(int j=0;j<this.curlen-1;j++){if(r[j].getKey().compareTo(r[j+1].getKey())>0){temp=r[j];r[j]=r[j+1];r[j+1]=temp;flag=true;}}}}public int Partition(int i,int j){RecordNode pivot = r[j];while (i<j){while (i<j && pivot.getKey().compareTo(r[j].getKey())<=0){ j--;}if(i<j){r[i]=r[j];i++;}while(i<j && pivot.getKey().compareTo(r[i].getKey())>0){ i++;}if(i<j){r[j]=r[i];j--;}}r[i]=pivot;return i;}public void qSort(int low,int high){if(low<high){int pivotloc = Partition(low,high);qSort(low,pivotloc-1);qSort(pivotloc + 1,high);}}public void quickSort(){qSort(0,this.curlen - 1);}public int seqSearch(Comparable key){int i=0;int n=length();while(i<n&&r[i].getKey().compareTo(key)!=0){ i++;}if(i<n){return i;}else{return -1;}}public int seqSearchWithGuard(Comparable key){ int i=length()-1;r[0].setKey(key);while((r[i].getKey()).compareTo(key)!=0){ i--;}if(i>0){return i;}else{return -1;}}public int binarySearch(Comparable key){ if(length()>0){int low=0;int high=length()-1;while(low<=high){int mid=(low +high)/2;if(r[mid].getKey().compareTo(key)==0){return mid;}else if(r[mid].getKey().compareTo(key)>0){high=mid-1;}else{low=mid+1;}}}return -1;}}package paixu;import java.util.Scanner;import paixu.RecordNode;import paixu.SeqList;public class Test2{public static void main(String[] args) throws Exception{ Scanner in=new Scanner(System.in);while(true){SeqList a=new SeqList(6);String d[]={"25","20","15","35","10","55"};for(int i=0;i<6;i++){RecordNode c=new RecordNode(d[i]);a.insert(i,c);}System.out.print("原数组:");a.display();System.out.println("");System.out.println("输入0~5进行选择");System.out.println("1直接插入排序");System.out.println("2带监视哨的直接插入排序");System.out.println("3希尔排序");System.out.println("4冒泡排序");System.out.println("5快速排序");System.out.println("0退出");int g=in.nextInt();switch(g){case 0:return;case 1:a.insertSort();System.out.print("排序后:");a.display();System.out.println("");break;case 2:a.insertSortWithGuard();System.out.print("排序后:");a.display();System.out.println("");break;case 3:int[] aa={1,3,5};a.shellSort(aa);System.out.print("排序后:");a.display();System.out.println("");break;case 4:a.bubbleSort();System.out.print("排序后:");a.display();System.out.println("");break;case 5:a.quickSort();System.out.print("排序后:");a.display();System.out.println("");break;}}}}import java.util.Scanner;public class Test{public static void main(String[] args){while(1<2){SeqList a=new SeqList(4);Scanner in=new Scanner(System.in);for(int i=0;i<4;i++){try{System.out.println("输入第"+i+"个元素:");String c=in.next();RecordNode d=new RecordNode(c);a.insert(i, d);}catch(Exception e){System.out.println("错误:"+e.getMessage());}}a.display();System.out.println("");System.out.println("不带监视哨顺序查找方法查找1的结果为"+a.seqSearch("1"));System.out.println("带监视哨顺序查找方法查找2的结果为"+a.seqSearchWithGuard("2"));System.out.println("二分查找方法查找3的结果为"+a.binarySearch("3"));}}}四、实验步骤及结果(包含简要的实验步骤流程、结论陈述,可附页)排序运行结果:查找运行结果:五、实验总结(包括心得体会、问题回答及实验改进意见)答:通过这次试验,编写和调用顺序查找和二分查找算法实现数据查找,我掌握两个查找算法的基本思想、实现方法和时间性能。
数据结构实验二
数据结构实验二数据结构实验二:队列与栈的实现一、实验目的本实验旨在通过实现队列和栈数据结构,加深对队列和栈实现原理的理解,并熟练掌握队列和栈的基本操作。
二、实验要求1.使用C/C++语言实现队列的基本操作:初始化队列、入队、出队、判空、判满等。
2.使用C/C++语言实现栈的基本操作:初始化栈、入栈、出栈、判空、判满等。
3.验证队列和栈的实现是否正确。
4.分析队列和栈的时间复杂度,并给出实验结果。
5.撰写实验报告,包括实验目的、实验原理、实验步骤、程序源代码、实验结果和分析、实验总结等内容。
三、实验原理1.队列:队列是一种先进先出(FIF0)的数据结构。
在队列中,数据元素按照进入队列的顺序排列,首元素是最先进入的元素,尾元素是最后进入的元素。
队列的基本操作有:初始化队列、入队、出队、判空、判满等。
2.栈:栈是一种后进先出(LIFO)的数据结构。
在栈中,数据元素按照进入栈的顺序排列,但是只能从栈顶进出,即最后进入的元素最先出栈。
栈的基本操作有:初始化栈、入栈、出栈、判空、判满等。
四、实验步骤1.实现队列的基本操作:1.初始化队列:创建一个空队列,并设置相关指针。
2.入队:将新元素插入到队尾。
3.出队:将队头元素删除,并返回其值。
4.判空:判断队列是否为空。
5.判满:判断队列是否已满。
2.实现栈的基本操作:1.初始化栈:创建一个空栈,并设置相关指针。
2.入栈:将新元素压入栈顶。
3.出栈:将栈顶元素弹出,并返回其值。
4.判空:判断栈是否为空。
5.判满:判断栈是否已满。
3.编写测试代码,验证队列和栈的基本操作是否正确。
4.进行性能测试,分析队列和栈的时间复杂度。
五、实验结果与分析1.队列的时间复杂度:●初始化队列:O(1)●入队:O(1)●出队:O(1)●判空:O(1)●判满:O(1)2.栈的时间复杂度:●初始化栈:O(1)●入栈:O(1)●出栈:O(1)●判空:O(1)●判满:O(1)3.根据实验结果可以看出,队列和栈的基本操作的时间复杂度都是O(1),即常数时间复杂度,具有高效性。
数据结构实验2
数据结构实验报告2第 2 次实验一、实验目的1、复习结构体、数组、指针;2、掌握数组的静态创建与动态创建;3、了解顺序存储的基本访问方法。
二、实验内容1、(必做题)每个学生的成绩信息包括:学号、语文、数学、英语、总分、加权平均分;采用动态方法创建数组用于存储若干学生的成绩信息;输入学生的学号、语文、数学、英语成绩;计算学生的总分和加权平均分(语文占30%,数学占50%,英语占20%);输出学生的成绩信息。
2、(必做题)可以在数组末尾追加新学生的成绩信息;可以根据学号,删除该学生的成绩信息。
3、(选做题)可以根据学号或总分,升序排序学生的成绩信息。
三、算法描述(采用自然语言描述)首先创建链表存储n个学生的成绩信息,再通过键盘输入学生的信息,创建指针p所指结点存储学生的成绩信息,从键盘读入学生人数,求出学生的总分和加权平均分,输出结果。
四、详细设计(画出程序流程图)五、程序代码(给出必要注释)#include <stdio.h>#include <stdlib.h>typedef struct Student{long studentID;int Chinese;int Math;int English;int sum;double ave;}student;void Input_Score(int n,student *stu){int i;student *p;p=stu;printf("请输入第考生信息:\n");for(i=0;i<n;i++){printf("请输入第%d个考生的学号:\n",i+1);scanf("%ld",&(p+i)->studentID);printf("请输入第%d个考生的语文成绩:\n",i+1);scanf("%d",&(p+i)->Chinese);printf("请输入第%d个考生的数学成绩:\n",i+1);scanf("%d",&(p+i)->Math);printf("请输入第%d个考生的英语成绩:\n",i+1);scanf("%d",&(p+i)->English);}}void Output_Score_Grade(int n,student *stu){int i;student *p;p=stu;for(i=0;i<n;i++){(p+i)->sum=(p+i)->Chinese+(p+i)->Math+(p+i)->English;(p+i)->ave=(p+i)->Chinese*0.3+(p+i)->Math*0.5+(p+i)->English*0.2;printf("考生的学号是:%ld\n",(p+i)->studentID);printf("考生的语文成绩是:%ld\n",(p+i)->Chinese);printf("考生的数学成绩是:%ld\n",(p+i)->Math);printf("考生的英语成绩是:%ld\n",(p+i)->English);printf("考生的总分是:%d\n",(p+i)->sum);printf("考生的加权平均分是:%f\n",(p+i)->ave);printf("\n");}}int main(){int n;printf("请输入学生数(1-100):\n");scanf("%d",&n);while(n<1||n>100){printf("请重新输入学生数(1-100):\n");scanf("%d",&n);}student *stu;stu=(student*)malloc(n*sizeof(student));if(!stu)exit(-1);Input_Score(n,stu);Output_Score_Grade(n,stu);}#include <stdio.h>#include <stdlib.h>typedef struct Student{long studentID;int Chinese;int Math;int English;int sum;double ave;}student;void Input_Score(int n,student *stu){int i;student *p;p=stu;printf("请输入第考生信息:\n");for(i=0;i<n;i++){printf("请输入第%d个考生的学号:\n",i+1);scanf("%ld",&(p+i)->studentID);printf("请输入第%d个考生的语文成绩:\n",i+1);scanf("%d",&(p+i)->Chinese);printf("请输入第%d个考生的数学成绩:\n",i+1);scanf("%d",&(p+i)->Math);printf("请输入第%d个考生的英语成绩:\n",i+1);scanf("%d",&(p+i)->English);}}void Input_Score2(n,stu2,a){int i;student *p;p=stu2;printf("请输入第考生信息:\n");for(i=n;i<n+a;i++){printf("请输入第%d个考生的学号:\n",i+1);scanf("%ld",&(p+i)->studentID);printf("请输入第%d个考生的语文成绩:\n",i+1);scanf("%d",&(p+i)->Chinese);printf("请输入第%d个考生的数学成绩:\n",i+1);scanf("%d",&(p+i)->Math);printf("请输入第%d个考生的英语成绩:\n",i+1);scanf("%d",&(p+i)->English);}}void Output_Score_Grade(int n,student *stu){int i;student *p;p=stu;for(i=0;i<n;i++){(p+i)->sum=(p+i)->Chinese+(p+i)->Math+(p+i)->English;(p+i)->ave=(p+i)->Chinese*0.3+(p+i)->Math*0.5+(p+i)->English*0.2;printf("考生的学号是:%ld\n",(p+i)->studentID);printf("考生的语文成绩是:%ld\n",(p+i)->Chinese);printf("考生的数学成绩是:%ld\n",(p+i)->Math);printf("考生的英语成绩是:%ld\n",(p+i)->English);printf("考生的总分是:%d\n",(p+i)->sum);printf("考生的加权平均分是:%f\n",(p+i)->ave);printf("\n");}}void Delete(student *stu,long m,int sum){student *p;p=stu;int i=0;while(p->studentID!=m){p++;i++;}for(int j=1;j<=sum-i;j++){p->studentID=(p+1)->studentID;p->Chinese=(p+1)->Chinese;p->Math=(p+1)->Math;p->English=(p+1)->English;p->sum=(p+1)->sum;p->ave=(p+1)->ave;p++;}}int main(){int n,a;long b;printf("请输入学生数(1-100):\n");scanf("%d",&n);while(n<1||n>100){printf("请重新输入学生数(1-100):\n");scanf("%d",&n);}student *stu,*stu2;stu=(student*)malloc(n*sizeof(student));if(!stu)exit(-1);Input_Score(n,stu);printf("请输入要添加的学生信息人数:\n");scanf("%d",&a);stu2=(student*)realloc(stu,(n+a)*sizeof(student));Input_Score2(n,stu2,a);printf("添加后学生的信息为:\n");Output_Score_Grade(n+a,stu2);printf("请输入要删除的学生的学号:\n");scanf("%ld",&b);Delete(stu2,b,n+a);printf("删除后的学生信息为:\n");Output_Score_Grade(n+a-1,stu2);}六、测试和结果(给出测试用例以及测试结果)七、用户手册(告诉用户如何使用程序)输入考生人数和考生信息便可以运行程序。
数据结构实验二数据结构实验二
status list_delete(sqlist &L,int i) { int *p,*q,e; if((iL.length)) { cout<<"你输入位置不合法!"<<endl; return error; } p=&(L.elem[i-1]); e=*p; q=L.elem+L.length-1; for(++p;p<=q;++p) *(p-1)=*p; --L.length; return e; } int main() { int i=0,j,in_num,a; //第j个元素前插入数据in_num sqlist M; list_init(M); M.length =10; cout<<"请输入10个数据(数据之间用空格分隔!)"<M.elem[i++]; list_output(M);) cout<<endl<<endl<<"请选者你要对表进行的操作:"<<endl<<" 1 插入数 据"<<endl <<" 2 删除数据"<>a; sqlist; status list_init(sqlist &L) //对表初始化定义 { L.elem =(int*)malloc(list_init_size*sizeof(int)); if (!L.elem) exit(error); L.length =0; L.listsize =list_init_size; return ok; } status list_output(sqlist &L) //输出一个表的函数定义 { cout<<endl<<"操作后的表为:"; for(int i=0;i<L.length ;i++) cout<<L.elem [i]<<" "; return ok; } status list_insert(sqlist &L,int i,int e) { int* newbase,*p,*q; if(iL.length +1) { cout<<endl=q;--p) *(p+1)=*p; *q=e; ++L.length ; return ok; }
数据结构试验二最终报告
第一个链表元素为(1,3,6,10,15,16,17,18,19,20)
第二个链表元素为(2,4,5,7,8,9,12,22)
第三组
第一个链表元素为()
第二个链表元素为(1,2,3,4,5,6,7,8,9,10)
<4>编写算法以构造带头结点的双循环链表。
第一组数据:链表元素为(1,2,3,4,5,6,7,8,9,10)
第二组数据:链表元素为(10,30,40,55,60,70,88,99,100)
<5>编写算法以判断一个带头结点的双循环链表是否是对称的,若成立,返回TRUE,否则返回FALSE。
第一组数据:链表元素为(1,2,3,4,5,4,3,2,1)
第二组数据:链表元素为(1,2,3,4,5,5,4,3,2,1)
第二组数据:链表元素为(1,2,3,4,5,6,7,8,9,10,11,12,13,15,20,18)
<3>利用递增有序的单循环链表表示集合,分别求两个链表表示的集合的交、并集所构成的链表。
第一组
第一个链表元素为(1,3,6,10,15,16,17,18,19,20)
第二个链表元素为(1,2,3,4,5,6,7,8,9,10,18,20,30)
第二组数据:链表元素为(10,20,30,40,50,60,70,80,90,100)
<2>设计算法以判断一个带头结点的单循环链表是否满足这样的条件:其中每个结点的元素值与其序号的差的绝对值不大于3。若成立,返回TRUE,否则返回FALSE。
第一组数据:链表元素为(1,2,3,4,5,6,7,8,9,10,12,13,15,16,18)
第一组数据返回True第二组数据返回False
数据结构实验报告二
数据结构实验报告(实验名称)1.实验目标熟练掌握栈的顺序存储结构和链式存储结构。
熟练掌握栈的有关算法设计,并在顺序栈和链栈上实现。
根据具体给定的需求,合理设计并实现相关结构和算法。
2.实验内容和要求内容:通过顺序栈和链栈结构设计并实现一个顺序栈,编写算法实现下列问题的求解。
<1>利用顺序栈实现将10进制数转换为16进制数。
第一组数据:4第二组数据:11第三组数据:254第四组数据:1357<2>对一个合法的数学表达式来说,其中的各大小括号“{”,“}”,“[”,“]”,“(”和“)”应是相互匹配的。
设计算法对以字符串形式读入的表达式S,判断其中的各括号是否是匹配的。
要求:顺序栈的实验要求顺序栈结构和运算定义,算法的实现以库文件方式实现,不得在测试主程序中直接实现;实验程序有较好可读性,各运算和变量的命名直观易懂,符合软件工程要求;程序有适当的注释。
链栈实验要求本次实验中的链栈结构指带头结点的单链表;链栈结构和运算定义,算法的实现以库文件方式实现,不得在测试主程序中直接实现;实验程序有较好可读性,各运算和变量的命名直观易懂,符合软件工程要求;程序有适当的注释。
3.数据结构设计顺序栈,链栈。
4.算法设计(除书上给出的基本运算(这部分不必给出设计思想),其它实验内容要给出算法设计思想)进制转换:先在函数中定义一个栈然后初始化栈,通过循环对x求余数,将余数放入栈中,循环取出栈中的元素,并判断其值,用switch-case,10-A,11-B,12-C,13-D,14-E,15-F。
判断符号是否配对:通过函数将栈传入,将栈中的元素放到一个数组中,然后通过循环给数组中的符号对应相反数数字,如“(”-1,“)”-(-1)。
判断是否合法时,将整数数组遍历相加,若和为0 ,表达式合法,若和不为0则不合法。
5.运行和测试顺序栈:1,2,链栈:1,26.总结和心得通过本次实验,很多东西还为掌握,要是不是的查书,查书时总结了一下内容栈是限定尽在表尾进行插入或者删除操作的线性表。
《数据结构》实验报告二(样例参考)
《数据结构》实验报告二系别:班级:学号:姓名:日期:指导教师:一、上机实验的问题和要求:单链表的查找、插入与删除。
设计算法,实现线性结构上的单链表的产生以及元素的查找、插入与删除。
具体实现要求:1.从键盘输入10个字符,产生不带表头的单链表,并输入结点值。
2.从键盘输入1个字符,在单链表中查找该结点的位置。
若找到,则显示“找到了”;否则,则显示“找不到”。
3.从键盘输入2个整数,一个表示欲插入的位置i,另一个表示欲插入的数值x,将x插入在对应位置上,输出单链表所有结点值,观察输出结果。
4.从键盘输入1个整数,表示欲删除结点的位置,输出单链表所有结点值,观察输出结果。
5.(★)将单链表中值重复的结点删除,使所得的结果表中各结点值均不相同,输出单链表所有结点值,观察输出结果。
6.(★)删除其中所有数据值为偶数的结点,输出单链表所有结点值,观察输出结果。
7.(★)将单链表分解成两个单链表A和B,使A链表中含有原链表中序号为奇数的元素,而B链表中含有原链表中序号为偶数的元素,且保持原来的相对顺序,分别输出单链表A和单链表B的所有结点值,观察输出结果。
二、程序设计的基本思想,原理和算法描述:(包括程序的结构,数据结构,输入/输出设计,符号名说明等)1.程序结构:定义一个主函数和五个子函数(分别用来实现单链表的创建、查找、插入、删除及单链表的打印)。
2.数据结构:定义一个结构体,作为单链表的结点。
typedef struct stu /*DataType可以是任何相应的数据类型如int, float或char*/ {char Name[Max]; /*定义了数据域,这里存放的是一个字符型数组*/struct stu *next; /*定义了指针域*/}student;3.输入输出设计:创建单链表函数:student *create();输入:通过scanf( )函数及for语句为数据域定义,并定义指针域的指针所指的下一个结点。
数据结构 实验二:单链表的基本操作
数据结构实验二:单链表的基本操作数据结构实验二:单链表的基本操作实验二:单链表的基本操作一、【实验目的】1、理解和掌握单链表的类型定义方法和结点生成方法。
2、掌握建立单链表和显示单链表元素的算法。
3、掌握单链表的查找、插入和删除算法二、【实验内容】1、建立一个整形数的单链表,手动输入10个数,并从屏幕显示单链表元素列表。
2、从键盘输入一个数,查找在以上创建的单链表中是否存在该数;如果存在,显示它的位置;如果不存在,给出相应提示。
3、删除上述单链表中指定位置的元素。
以下就是程序部分代码,恳请调试并补足并使之恰当运转:1.linlist.htypedefstructnode{datatypedata;structnode*next;}slnode;voidlistinitiate(slnode**head)/*初始化*/{/*如果有内存空间,申请头结点空间并使头指针head指向头结点*/if((*head=(slnode*)malloc(sizeof(slnode)))==null)exit(1);(*head)->next=null;/*置链尾标记null*/}intlistlength(slnode*head){slnode*p=head;/*p指向首元结点*/intsize=0;/*size初始为0*/while(p->next!=null)/*循环计数*/{p=p->next;size++;}returnsize;}intlistinsert(slnode*head,inti,datatypex)/*在带头结点的单链表head的数据元素ai(0≤i≤size)结点前*//*填入一个存放数据元素x的结点*/{slnode*p,*q;intj;p=head;/*p指向首元结点*/j=-1;/*j起始为-1*/while(p->next!=null&&j<i-1)/*最终让指针p指向数据元素ai-1结点*/{p=p->next;j++;}if(j!=i-1){printf(\填入边线参数弄错!\return0;}/*生成新结点由指针q指示*/if((q=(slnode*)malloc(sizeof(slnode)))==null)exit(1);q->data=x;q->next=p->next;/*给指针q->next赋值*/p->next=q;/*给指针p->next重新赋值*/return1;}intlistdelete(slnode*head,inti,datatype*x)/*删除带头结点的单链表head的数据元素ai(0≤i≤size-1)结点*//*删除结点的数据元素域值由x带回。
数据结构实验二 线性表
数据结构实验二线性表数据结构实验二线性表1. 实验目的1.1 理解线性表的概念和特性1.2 学习线性表的顺序存储结构和链式存储结构1.3 掌握线性表的基本操作:初始化、插入、删除、查找、修改、遍历等1.4 熟悉线性表的应用场景2. 实验内容2.1 线性表的顺序存储结构实现2.1.1 定义线性表结构体2.1.2 初始化线性表2.1.3 插入元素2.1.4 删除元素2.1.5 查找元素2.1.6 修改元素2.1.7 遍历线性表2.2 线性表的链式存储结构实现2.2.1 定义链表节点结构体2.2.2 初始化链表2.2.3 插入元素2.2.4 删除元素2.2.5 查找元素2.2.6 修改元素2.2.7 遍历链表3. 实验步骤3.1 实现顺序存储结构的线性表3.2 实现链式存储结构的线性表3.3 编写测试程序,验证线性表的各种操作是否正确3.4 进行性能测试,比较两种存储结构的效率差异4. 实验结果与分析4.1 执行测试程序,检查线性表的操作结果是否正确4.2 对比顺序存储结构和链式存储结构的性能差异4.3 分析线性表的应用场景,总结线性表的优缺点5. 实验总结5.1 总结线性表的定义和基本操作5.2 回顾实验中遇到的问题和解决方法5.3 提出对线性表实现的改进方向和思考附件:请参考附件中的源代码和实验报告模板。
法律名词及注释:1. 版权:指对某一作品享有的法律上的权利,包括复制权、发行权、改编权等。
2. 法律责任:指违反法律或合同规定所承担的责任。
3. 保密义务:指个人或组织根据法律、法规、合同等规定需要承担的保密责任。
4.知识产权:指人们在社会实践中所创造的智力劳动成果所享有的权利,包括专利权、著作权、商标权等。
数据结构实验报告(二)栈的应用
数据结构实验报告(⼆)栈的应⽤实验说明数据结构实验⼆ 栈的实验——栈的简单应⽤⼀、实验⽬的通过本实验使学⽣了解栈的简单应⽤,熟悉栈的特性及栈在顺序存储上的操作特点,深刻理解栈的基本操作与⽤栈解决应⽤问题的关系;特别训练学⽣使⽤栈解决实际问题的能⼒,为今后⽤栈解决相关问题奠定基础。
⼆、实验内容1.编程实现对给定的⼀组括号序列判断其是否匹配正确。
要求:(1)它必须成对出现,如“(”“)”是⼀对,“[”与“]”是⼀对;(2)出现时有严格的左右关系;(3)可以以嵌套的⽅式同时出现多组多括号,但必须是包含式嵌套,不允许交叉式嵌套。
⽐如“( )”、“[([][])]”这样是正确的,“[(])”或“([()))”或 “(()]”是不正确的。
(4)将处理的括号扩展为针对“()”“[]”“{}”三类。
2.编程实现⼀个简单的⾏编辑功能:⽤户可以输⼊⼀⾏内容,并可进⾏简易编辑。
要求:(1)遇到输⼊部分内容有误时操作退格符“#”表⽰前⼀位⽆效;(2)“@”表⽰之前的内容均⽆效。
实验报告1.实现功能描述编程实现对给定的⼀组括号序列判断其是否匹配正确,将处理的括号扩展为针对“()”“[]”“{}”三类,遇到输⼊部分内容有误时操作退格符“#”表⽰前⼀位⽆效;“@”表⽰之前的内容均⽆效。
2.⽅案⽐较与选择(1)可以使⽤栈和队列来实现。
因为栈的功能⾜以完成题⽬要求,所以初步打算使⽤栈来实现。
(2)因为编写⼀个标准的栈⽐较繁琐,⽽且本题中也没有⽤到所有栈的标准操作,所以通过模拟栈来完成本题。
(3)可以使⽤数组或链表来模拟栈。
因为括号匹配只有3对,所需空间不是很⼤,⼜因为特殊操作#、@可以在数组中通过-1和赋0值实现,因此选择了数组法来模拟栈。
3.设计算法描述(1)定义3个变量,分别⽤于记录()、[]、{}的出现次数。
遇到左符号时变量++,遇到右符号时--,变量为0时表⽰空栈。
当读到#时,再往前读⼀个字符,如果是()、[]、{}中的⼀种,则对其进⾏反向运算,即遇到右符号时++,遇到左符号时--。
数据结构实验2
《数据结构》实验报告实验序号:2 实验项目名称:顺序表的操作学号姓名专业、班级实验地点指导教师实验时间一、实验目的及要求1.掌握线性表的顺序存储类型;2.熟练掌握顺序表的基本操作和具体的函数实现。
二、实验设备(环境)及要求微型计算机;windows 操作系统;Microsoft Visual Studio 6.0集成开发环境。
三、实验内容与步骤1.设A、B均为用数组实现的List类型的顺序表,试设计一个函数Alternate (A,B),从表A中第1个元素开始,交替地用表A和表B中元素组成一个新表。
2.顺序表表示和实现线性表的如下:# define LIST_INIT_SIZE 10# define LISTINCREMENT 5typedef struct{ElemType *elem;int length ;int ListSize;} sqlist;int InitList_sq(sqlist *l) /*initial the list l*/{l->elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));if (!l->elem){printf("无法分配空间!");return 1;}else{l->length=0;l->ListSize=LIST_INIT_SIZE;printf("ok");return 0;}}void main(){sqlist L;InitList_sq(&L);……}【要求】1、实现顺序表的插入、删除、按值查找等基本操作;2、假设构建的是非递增有序顺序表,设计算法实现从该有序顺序表中删除所有其值重复的元素,使得表中所有元素的值均不同。
四、实验结果与数据处理附源程序清单:1.#include<stdio.h>#include<stdlib.h>#define LIST_INIT_SIZE 10#define LISTINCREMENT 5typedef int ElemType;typedef struct{ElemType *elem;int length ;int ListSize;} sqlist;int InitList_sq(sqlist *l)/*initial the list l*/{l->elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));if (!l->elem){printf("无法分配空间!");return 1;}else{l->length=0;l->ListSize=LIST_INIT_SIZE;printf("ok\n");return 0;}}void Alternate(sqlist *A,sqlist*B){ElemType i;sqlist list;sqlist *C;C=&list;InitList_sq(C);C->length=A->length+B->length;while(i){if(C->length>=C->ListSize){ElemType *newbase;newbase=(ElemType*)realloc(C->elem,(C->ListSize+LISTINCREMENT)*sizeof(ElemType));C->elem=newbase;C->ListSize+=LISTINCREMENT;}else break;}for(i=0;i<C->length;i++){C->elem[2*i]=A->elem[i];C->elem[2*i+1]=B->elem[i];}for(i=0;i<C->length;i++)printf("%d ",C->elem[i]);}void main(){ElemType i;sqlist list1,list2,*A,*B;A=&list1;B=&list2;InitList_sq(A);InitList_sq(B);printf("请输入A指向的5个整数:\n");for(i=0;i<5;i++)scanf("%d",&A->elem[i]);A->length=i;printf("请输入B指向的5个整数:\n");for(i=0;i<5;i++)scanf("%d",&B->elem[i]);B->length=i;Alternate(A,B);printf("\n");}2.#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define LIST_INIT_SIZE 100#define LISINCREMENT 10#define ElemType int#define Status inttypedef struct Sq{ElemType *elem;int length;int listsize;}SqList;Status InitList(SqList *L){L->elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L->elem)return 0;L->length=0;L->listsize=LIST_INIT_SIZE;return 1;}//---------------------------------------------------------插入Status ListInsert(SqList *L,int i,ElemType e){int *q,*p;if(i<1||i>L->length)return 0;if(L->length>L->listsize){ElemType*newbase=(ElemType*)realloc(L->elem,(LIST_INIT_SIZE+LISINCREMENT)*size of(ElemType));if(!newbase)return 0;L->elem=newbase;L->listsize+=(LISINCREMENT);}q=&(L->elem[i-1]);for(p=&(L->elem[L->length-1]);p>=q;--p)*(p+1)=*p;*q=e;++L->length;return 1;}//---------------------------------------------------------删除Status ListDelete(SqList *L,int i,ElemType e){int *p,*q;if(i<1||i>L->length)return 0;p=&(L->elem[i-1]);e=*p;q=L->elem+L->length-1;for(++p;p<=q;++p)*(p-1)=*p;--L->length;return 1;}//---------------------------------------------------------查找Status LocateElem(SqList *L, ElemType e){//本算法实现查找顺序表中值为e的元素,如果查找成功,返回元素位序,否则返回0 int i;for(i=0;i<L->length;i++)if(L->elem[i]==e){printf("被查找元素的位置:%2d\n",i+1);return i+1;}// 下标为i的元素值等于e,返回其位号i+1else{printf("没有该元素!\n");return 0;}//退出循环,说明查找失败}//-------------------------------------------------------删除重复void DelDouble(SqList *L){int i,j,k;int tmp;if(L->length == 0 ){printf("表空\n"); exit (1);}i=0;while ( i < L->length ) { //循环检测j = i + 1;tmp = L->elem[i];while( j < L->length ) { //对于每一个i, 重复检测一遍后续元素if( tmp == L->elem[j]){ //如果相等,删除此结点,后续元素前移for( k = j+1; k < L->length; k++ ) L->elem[k-1] = L->elem[k];L->length--; //表最后元素位置减1}else j++;}i++;}}int main(void){int i,j,e,lo,temp;SqList *L=(SqList*)malloc(sizeof(SqList));InitList(L);//------------------------------------------输入顺序表printf("请输顺序表的长度:\n");scanf("%d",&L->length);printf("请输入顺序表的各个元素:\n");for(i=0;i<L->length;++i)scanf("%d",&L->elem[i]);printf("输入的顺序表是:\n");for (i=0;i<L->length;++i){printf("%d ",L->elem[i]);}printf("\n");printf("请输入插入的位置以及节点:\n");//---------------------插入scanf("%d%d",&j,&e);ListInsert(L,j,e);printf("插入后的顺序表为:\n");for (i=0;i<L->length;++i){printf("%d ",L->elem[i]);}printf("\n");printf("请输入要删除的位置:");//----------------------------删除scanf("%d",&lo);ListDelete(L,lo,temp);for (i=0;i<L->length;++i){printf("%d ",L->elem[i]);}printf("\n");printf("输入要查找的值:"); //-------------------------------查找scanf("%d",&e);i=LocateElem(L,e);printf("删除重复元素后顺序表为:\n");//----------------------删除重复DelDouble(L);for (i=0;i<L->length;++i){printf("%d ",L->elem[i]);}printf("\n");free(L);return 0;}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Show(s);
printf("Enter Decimal number & Base number: ");
scanf("%d %d", &x, &y);
s=convert(x,y);
printf("Decimal number %d converts to 16 base number is: \n",x);
{
int data[StackInitSize];
int top;
}SeqStack;
SeqStack*InitStack()
{
SeqStack *s;
s=(SeqStack * )malloc(sizeof(SeqStack));
if(s!=NULL)
{
s->top=0;
return s;
}
else
printf("%d = ",x);
Show(s);
s=convert(x,8);
printf("Decimal number %d converts to 8 base number is: \n",x);
printf("%d = ",x);
Show(s);
s=convert(x,16);
printf("Decimal number %d converts to 16 base number is: \n",x);
exit(0);
}
else
{
s->data[s->top]=x;
s->top++;
}
}
SeqStack*convert(int x, int y)
{
SeqStack *s;
s=InitStack();
int a;
while(x!=0)
{
a=x%y;
Push(s,a);
x=x/y;
}
return s;
2)要求:算术表达式可包含加、减、乘、除、十进制整数和小括号,利用栈实现
3.实验过程记录(源程序、测试用例、测试结果及心得体会等)
1.十进制数与N进制数据的转换
#include<stdio.h>
#include<stdlib.h>
#define StackInitSize 100
typedef struct
实验报告
学院(系)名称:计算机与通信工程学院
姓名
王宏昌
学号
20135628
专业
计算机科学与技术
班级
2班
实验名称
实验二栈与队列应用
课程名称
数据结构
课程代码
实验时间
2016
实验地点
7-220
批改意见
成绩
教师签字:
1.实验目的
理解栈和队列的逻辑特点;掌握栈和队列基本操作的实现,并能达到在实际问题背景下的灵活运用栈或队列结构解决问题的程度。
printf("%d = ",x);
Show(s);
return 0;
}
2.算术表达式求值算法
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 100
typedefstruct node
{
chardata;
structnode *next;
}LinkStack;
2.实验要求
具体实验题目:(任课教师根据实验大纲自己指定)
每位同学完成下面2个题目:
1.十进制数与N进制数据的转换
1)问题描述:将从键盘输入的十进制数转换为N(如二进制、八进制、十六进制)进制数据。
2)要求:利用顺序栈实现数制转换问题
2.算术表达式求值算法
1)问题描述:从键盘输入一个算术表达式并输出它的结果
{
printf("NULL! EXIT!");
exit(0);
}
else
return s->data[s->top];
}
voidDestroyStack(SeqStack *s)
{
free(s);
printf("Stack Destroed!\n");
}
voidShow(SeqStack *s)
{
int t;
if(IsEmpty(s))
{
printf("NULL! EXIT!");
exit(0);
}
else
{
t=s->top-1;
while(t>=0)
{
if(s->data[t]<10)
printf("%d",s->data[t]);
else
{
switch(s->data[t])
{
case 10:
printf("A");
LinkStack*InitStack()
{
LinkStack*top;
top=(LinkStack * )malloc(sizeof(LinkStack));
if(!top)
{
printf("ERROR! NO SPACE! EXIT!");
exit(0);
}
else
top=NULL;
return top;
}
intPop(SeqStack *s)
{
int t;
if(IsEmpty(s))
{
printf("NULL! EXIT!");
exit(0);
}
else
{
t=s->data[s->top];
s->top--;
return t;
}
}
intTopStack(SeqStack *s)//取栈顶
{
if(IsEmpty(s))
}
intIsEmpty(LinkStack *top)
{
return top!=NULL?0:1;
t--;
}
printf("\n");
}
}
int main()
{
SeqStack *s;
int x,y;
printf("Enter Decimal number & Base number: ");
scanf("%d", &x);
s=convert(x,2);
printf("Decimal number %d converts to 2 base number is: \n",x);
{
printf("ERROR! NO SPACE! EXIT!");
exit(0);
}
}
intIsEmpty(SeqStack *s)
{
return (s->top==0)?1:0;
}
voidPush(SeqStack *s, int x)
{
if(s->top==StackInitSize-1)
{
printf("FULL! EXIT!");
//break;
case 11:
printf(ቤተ መጻሕፍቲ ባይዱB");
//break;
case 12:
printf("C");
//break;
case 13:
printf("D");
//break;
case 14:
printf("E");
//break;
case 15:
printf("F");
//break;
}
}