数据结构实验报告[1]
数据结构实验报告-线性表(顺序表实现)
实验1:线性表(顺序表的实现)一、实验项目名称顺序表基本操作的实现二、实验目的掌握线性表的基本操作在顺序存储结构上的实现。
三、实验基本原理顺序表是由地址连续的的向量实现的,便于实现随机访问。
顺序表进行插入和删除运算时,平均需要移动表中大约一半的数据元素,容量难以扩充四、主要仪器设备及耗材Window 11、Dev-C++5.11五、实验步骤1.导入库和一些预定义:2.定义顺序表:3.初始化:4.插入元素:5.查询元素:6.删除元素:7.销毁顺序表:8.清空顺序表:9.顺序表长度:10.判空:11.定位满足大小关系的元素(默认小于):12.查询前驱:13.查询后继:14.输出顺序表15.归并顺序表16.写测试程序以及主函数对顺序表的每一个操作写一个测试函数,然后在主函数用while+switch-case的方式实现一个带菜单的简易测试程序,代码见“实验完整代码”。
实验完整代码:#include <bits/stdc++.h>using namespace std;#define error 0#define overflow -2#define initSize 100#define addSize 10#define compareTo <=typedef int ElemType;struct List{ElemType *elem;int len;int listsize;}L;void init(List &L){L.elem = (ElemType *) malloc(initSize * sizeof(ElemType)); if(!L.elem){cout << "分配内存失败!";exit(overflow);}L.len = 0;L.listsize = initSize;}void destroy(List &L){free(L.elem);L.len = L.listsize = 0;}void clear(List &L){L.len = 0;}bool empty(List L){if(L.len == 0) return true;else return false;}int length(List L){return L.len;}ElemType getElem(List L,int i){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}return L.elem[i - 1];}bool compare(ElemType a,ElemType b) {return a compareTo b;}int locateElem(List L,ElemType e) {for(int i = 0;i < L.len;i++){if(compare(L.elem[i],e))return i;}return -1;}int check1(List L,ElemType e){int idx = -1;for(int i = 0;i < L.len;i++)if(L.elem[i] == e)idx = i;return idx;}bool check2(List L,ElemType e){int idx = -1;for(int i = L.len - 1;i >= 0;i--)if(L.elem[i] == e)idx = i;return idx;}int priorElem(List L,ElemType cur_e,ElemType pre_e[]) {int idx = check1(L,cur_e);if(idx == 0 || idx == -1){string str = "";str = idx == 0 ? "无前驱结点" : "不存在该元素";cout << str;exit(error);}int cnt = 0;for(int i = 1;i < L.len;i++){if(L.elem[i] == cur_e){pre_e[cnt ++] = L.elem[i - 1];}}return cnt;}int nextElem(List L,ElemType cur_e,ElemType next_e[]){int idx = check2(L,cur_e);if(idx == L.len - 1 || idx == - 1){string str = "";str = idx == -1 ? "不存在该元素" : "无后驱结点";cout << str;exit(error);}int cnt = 0;for(int i = 0;i < L.len - 1;i++){if(L.elem[i] == cur_e){next_e[cnt ++] = L.elem[i + 1];}}return cnt;}void insert(List &L,int i,ElemType e){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}if(L.len >= L.listsize){ElemType *newbase = (ElemType *)realloc(L.elem,(L.listsize + addSize) * sizeof(ElemType));if(!newbase){cout << "内存分配失败!";exit(overflow);}L.elem = newbase;L.listsize += addSize;for(int j = L.len;j > i - 1;j--)L.elem[j] = L.elem[j - 1];L.elem[i - 1] = e;L.len ++;}void deleteList(List &L,int i,ElemType &e){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}e = L.elem[i - 1];for(int j = i - 1;j < L.len;j++)L.elem[j] = L.elem[j + 1];L.len --;}void merge(List L,List L2,List &L3){L3.elem = (ElemType *)malloc((L.len + L2.len) * sizeof(ElemType)); L3.len = L.len + L2.len;L3.listsize = initSize;if(!L3.elem){cout << "内存分配异常";exit(overflow);}int i = 0,j = 0,k = 0;while(i < L.len && j < L2.len){if(L.elem[i] <= L2.elem[j])L3.elem[k ++] = L.elem[i ++];else L3.elem[k ++] = L2.elem[j ++];}while(i < L.len)L3.elem[k ++] = L.elem[i ++];while(j < L2.len)L3.elem[k ++] = L2.elem[j ++];}bool visit(List L){if(L.len == 0) return false;for(int i = 0;i < L.len;i++)cout << L.elem[i] << " ";cout << endl;return true;}void listTraverse(List L){if(!visit(L)) return;}void partion(List *L){int a[100000],b[100000],len3 = 0,len2 = 0; memset(a,0,sizeof a);memset(b,0,sizeof b);for(int i = 0;i < L->len;i++){if(L->elem[i] % 2 == 0)b[len2 ++] = L->elem[i];elsea[len3 ++] = L->elem[i];}for(int i = 0;i < len3;i++)L->elem[i] = a[i];for(int i = 0,j = len3;i < len2;i++,j++) L->elem[j] = b[i];cout << "输出顺序表:" << endl;for(int i = 0;i < L->len;i++)cout << L->elem[i] << " ";cout << endl;}//以下是测试函数------------------------------------void test1(List &list){init(list);cout << "初始化完成!" << endl;}void test2(List &list){if(list.listsize == 0)cout << "线性表不存在!" << endl;else{int len;ElemType num;cout << "选择插入的元素数量:" << endl;cin >> len;cout << "依次输入要插入的元素:" << endl;for(int i = 1;i <= len;i++){cin >> num;insert(list,i,num);}cout << "操作成功!" << endl;}}void test3(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "请输入要返回的元素的下标" << endl;int idx;cin >> idx;cout << "线性表中第" << idx << "个元素是:" << getElem(L,idx) << endl;}}void test4(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{int idx;ElemType num;cout << "请输入要删除的元素在线性表的位置" << endl;cin >> idx;deleteList(L,idx,num);cout << "操作成功!" << endl << "被删除的元素是:" << num << endl; }}void test5(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{destroy(L);cout << "线性表已被销毁" << endl;}}void test6(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{clear(L);cout << "线性表已被清空" << endl;}}void test7(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else cout << "线性表的长度现在是:" << length(L) << endl;}void test8(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else if(empty(L))cout << "线性表现在为空" << endl;else cout << "线性表现在非空" << endl;}void test9(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num;cout << "请输入待判定的元素:" << endl;cin >> num;cout << "第一个与目标元素满足大小关系的元素的位置:" << locateElem(L,num) << endl;}}void test10(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = priorElem(L,num,num2);cout << num << "的前驱为:" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test11(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = nextElem(L,num,num2);cout << num << "的后继为:" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test12(List list){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "输出线性表所有元素:" << endl;listTraverse(list);}}void test13(){if(L.listsize == 0)cout << "初始线性表不存在!" << endl; else{List L2,L3;cout << "初始化一个新线性表" << endl;test1(L2);test2(L2);cout << "归并两个线性表" << endl;merge(L,L2,L3);cout << "归并成功!" << endl;cout << "输出合并后的线性表" << endl;listTraverse(L3);}}void test14(){partion(&L);cout << "奇偶数分区成功!" << endl;}int main(){std::ios::sync_with_stdio(false);cin.tie(0),cout.tie(0);int op = 0;while(op != 15){cout << "-----------------menu--------------------" << endl;cout << "--------------1:初始化------------------" << endl;cout << "--------------2:插入元素----------------" << endl;cout << "--------------3:查询元素----------------" << endl;cout << "--------------4:删除元素----------------" << endl;cout << "--------------5:销毁线性表--------------" << endl;cout << "--------------6:清空线性表--------------" << endl;cout << "--------------7:线性表长度--------------" << endl;cout << "--------------8:线性表是否为空----------" << endl;cout << "--------------9:定位满足大小关系的元素--" << endl;cout << "--------------10:查询前驱---------------" << endl;cout << "--------------11:查询后继---------------" << endl;cout << "--------------12:输出线性表-------------" << endl;cout << "--------------13:归并线性表-------------" << endl;cout << "--------------14:奇偶分区---------------" << endl;cout << "--------------15: 退出测试程序-----------" << endl;cout << "请输入指令编号:" << endl; if(!(cin >> op)){cin.clear();cin.ignore(INT_MAX,'\n');cout << "请输入整数!" << endl;continue;}switch(op){case 1:test1(L);break;case 2:test2(L);break;case 3:test3();break;case 4:test4();break;case 5:test5();break;case 6:test6();break;case 7:test7();break;case 8:test8();break;case 9:test9();break;case 10:test10();break;case 11:test11();break;case 12:test12(L);break;case 13:test13();break;case 14:test14();break;case 15:cout << "测试结束!" << endl;default:cout << "请输入正确的指令编号!" << endl;}}return 0;}六、实验数据及处理结果1.初始化:2.插入元素3.查询元素(返回的是数组下标,下标从0开始)4.删除元素(位置从1开始)5.销毁顺序表6.清空顺序表7.顺序表长度(销毁或清空操作前)8.判空(销毁或清空操作前)9.定位满足大小关系的元素(销毁或清空操作前)说明:这里默认找第一个小于目标元素的位置且下标从0开始,当前顺序表的数据为:1 4 2 510.前驱(销毁或清空操作前)11.后继(销毁或清空操作前)12.输出顺序表(销毁或清空操作前)13.归并顺序表(销毁或清空操作前)七、思考讨论题或体会或对改进实验的建议通过本次实验,我掌握了定义线性表的顺序存储类型,加深了对顺序存储结构的理解,进一步巩固和理解了顺序表的基本操作,如建立、查找、插入和删除等。
《数据结构》实验1实验报告
南京工程学院实验报告<班级>_<学号>_<实验X>.RAR文件形式交付指导老师。
一、实验目的1.熟悉上机环境,进一步掌握语言的结构特点。
2.掌握线性表的顺序存储结构的定义及实现。
3.掌握线性表的链式存储结构——单链表的定义及实现。
4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5.掌握线性表在链式存储结构——单链表中的各种基本操作。
二、实验内容1.顺序线性表的建立、插入及删除。
2.链式线性表的建立、插入及删除。
三、实验步骤1.建立含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。
2.利用前面的实验先建立一个顺序表L={21,23,14,5,56,17,31},然后在第i个位置插入元素68。
3.建立一个带头结点的单链表,结点的值域为整型数据。
要求将用户输入的数据按尾插入法来建立相应单链表。
四、程序主要语句及作用程序1的主要代码(附简要注释)public struct sequenlist{public const int MAXSIZE=1024; /*最大值为1024*/public elemtype[] vec;public int len; /* 顺序表的长度 */public sequenlist( int n){vec=new elemtype[MAXSIZE ];len = n;}};class Program{static void Main(string[] args){sequenlist list1 = new sequenlist(5);for (int i = 0; i < 5; i++){list1.vec[i] = i;}for (int i = 0; i < 5; i++){Console.Write("{0}---", list1.vec[i]) ;}Console.WriteLine("\n");Console.WriteLine("表长:{0}\n",list1.len );Console.ReadKey();}}程序2的主要代码(附简要注释)public void insertlist(int i, int x){if (len >= MAXSIZE)throw new Exception("上溢"); /*长度大于最大值则抛出异常*/if (i < 1 || i > len + 1)throw new Exception("位置");/插入位置小于1或大于len+1则抛出插入位置错误的异常for (int j = len; j >= i; j--)vec[j] = vec[j - 1]; //注意第j个元素存在数组下标为j-1处vec[i - 1] = x;len++;}};class Program{static void Main(string[] args){sequenlist list2 = new sequenlist(7);list2.vec[0] = 21;list2.vec[1] = 23;list2.vec[2] = 14;list2.vec[3] = 5;list2.vec[4] = 56;list2.vec[5] = 17;list2.vec[6] = 31;Console.Write("请输入第i个位置插入元素:");int loc =Convert.ToInt32( Console.ReadLine());Console.Write("请输入第{0}个位置插入的元素:", loc);int ele = Convert.ToInt32(Console.ReadLine());Console.WriteLine("插入前的线性表:");for (int i = 0; i < list2.len ; i++){Console.Write("{0}---", list2.vec[i]);}Console.WriteLine("\n");list2.insertlist(loc, ele);Console.WriteLine("插入后的线性表:");for (int i = 0; i < list2.len ; i++){Console.Write("{0}---", list2.vec[i]);}Console.WriteLine("\n");Console.ReadKey();}}程序3的主要代码(附简要注释)class Node{private int num;public int Num{set { num = value; }/输入值get { return num; }/获得值}private Node next;public Node Next{set { next = value; }get { return next; }}}class Pp{static void Main(string[] args){Node head;Node tempNode, tempNode1;int i;head = new Node();Console.WriteLine("输入六项数据:\n");Console.Write("输入第1项数据:");head.Num = Convert.ToInt32(Console.ReadLine());head.Next = null;tempNode = head;for (i = 1; i < 6; i++){tempNode1 = new Node();Console.Write("输入第{0}项数据:",i+1);tempNode1.Num = Convert.ToInt32(Console.ReadLine());/插入项转换为整形数值 tempNode1.Next = null;tempNode.Next = tempNode1;tempNode = tempNode.Next;}Console.WriteLine("线性表:");tempNode = head;for (i = 0; i < 6; i++){Console.Write("{0}", tempNode.Num);if (i < 5){Console.Write("--");}tempNode = tempNode.Next;}Console.ReadKey();}}五、程序运行结果截图程序1程序2程序3六、收获,体会及问题(写得越详细、越个性化、越真实越好,否则我不知道你做这个实验的心路历程,也就无法充分地判断你是否是独立完成的这个实验、你是否在做这个实验时进行了认真仔细地思考、通过这个实验你是否在实践能力上得到了提高)这次试验刚开始做时完全不知道从哪下手,才刚上了几节课,对于线性表、链式表都不是理解的很透彻,不知道用哪个软件编写程序。
数据结构实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中重要的基础课程,通过本次实验,旨在深入理解和掌握常见数据结构的基本概念、操作方法以及在实际问题中的应用。
具体目的包括:1、熟练掌握线性表(如顺序表、链表)的基本操作,如插入、删除、查找等。
2、理解栈和队列的特性,并能够实现其基本操作。
3、掌握树(二叉树、二叉搜索树)的遍历算法和基本操作。
4、学会使用图的数据结构,并实现图的遍历和相关算法。
二、实验环境本次实验使用的编程环境为具体编程环境名称,编程语言为具体编程语言名称。
三、实验内容及步骤(一)线性表的实现与操作1、顺序表的实现定义顺序表的数据结构,包括数组和表的长度等。
实现顺序表的初始化、插入、删除和查找操作。
2、链表的实现定义链表的节点结构,包含数据域和指针域。
实现链表的创建、插入、删除和查找操作。
(二)栈和队列的实现1、栈的实现使用数组或链表实现栈的数据结构。
实现栈的入栈、出栈和栈顶元素获取操作。
2、队列的实现采用循环队列的方式实现队列的数据结构。
完成队列的入队、出队和队头队尾元素获取操作。
(三)树的实现与遍历1、二叉树的创建以递归或迭代的方式创建二叉树。
2、二叉树的遍历实现前序遍历、中序遍历和后序遍历算法。
3、二叉搜索树的操作实现二叉搜索树的插入、删除和查找操作。
(四)图的实现与遍历1、图的表示使用邻接矩阵或邻接表来表示图的数据结构。
2、图的遍历实现深度优先遍历和广度优先遍历算法。
四、实验结果与分析(一)线性表1、顺序表插入操作在表尾进行时效率较高,在表头或中间位置插入时需要移动大量元素,时间复杂度较高。
删除操作同理,在表尾删除效率高,在表头或中间删除需要移动元素。
2、链表插入和删除操作只需修改指针,时间复杂度较低,但查找操作需要遍历链表,效率相对较低。
(二)栈和队列1、栈栈的特点是先进后出,适用于函数调用、表达式求值等场景。
入栈和出栈操作的时间复杂度均为 O(1)。
2、队列队列的特点是先进先出,常用于排队、任务调度等场景。
数据结构实验报告1-线性结构的顺序存储
教师签名: 2008 年 月 日
第2页共2页
2、参照课本,定义一个向量类模板,编写它的成员函数模板,对类模板加以实现;编写向量的并、 交运算功能函数;编写主程序,对两个向量进行分别进行合并、交运算。
3、通过阅读课本栈类板代码,理解栈类操作特点;编写一个借助于栈,将二进制数转换为十进制数 字串的程序;编写汉诺塔问题程序,理解函数的递归调用。
4、参照课本,定义一个顺序队列类模板,编写它的成员函数模板 ,对类模板加以实现;编写主程序, 对队列进行各种基本操作,理解队列的操作特性。
五、 实验总结(包括心得体会、问题回答及实验改进意见,可附页)
通过本次实验,基本上能够理解线性结构的顺序存储方式及各种不同线性结构的操作方式;顺序存 储方式主要用于线性的数据结构,它把逻辑上相邻的数据元素存储在物理上相邻的存储单元里结点之间 的关系由存储单元的邻接关系来体现。线性表、向量、栈、队列都属于线性结构的顺序存储,各结点的 物理地址是相邻的,每一次插入、删除运算会引起相应结点物理地址的重新排列;栈的操作特点是先进 后出,而队列的操作特点是先进先出。
2、 对两个向量进行合并、交运算,结果如下: 输入向量 La 的结点元素:1 2 3 4 5,输入 Lb 的结点元素:1 2 3 4 5 6,则两向量的交集为:1 2 3 4 5;并集为:1 2 3 4 5 6。
3、(1)将二进制数转换为十进制数字串的程序,结果如下: 输入要转换的带符号整数 x:+3;则 x 转换成十进制数字串输出为:+3
Байду номын сангаас
第1页共2页
四、 实验结果(包括程序或图表、结论陈述、数据记录及分析等,可附页)
1、 对线性表进行插入、删除、定位等操作,结果如下: 输入线性表元素:1 2 3 4 5,(1)选择插入,输入插入位置 2,插入值 9,则新的线性表为:1 2 9 3 4 5;(2)选择删除,输入删除元素序号 5,则新的线性表为:1 2 9 3 4;(3)选择取值,输入要求 值元素序号 2,则屏幕输出:第2个元素的值为 9;(4)选择查找,输入要查找的元素值 9,则屏幕输 出:要查找元素的序号为 2。
数据结构上机实验报告
数据结构实验报告课程数据结构 _ 院系专业班级实验地点姓名学号实验时间指导老师数据结构上机实验报告1一﹑实验名称:实验一——链表二﹑实验目的:1.了解线性表的逻辑结构特性;2.熟悉链表的基本运算在顺序存储结构上的实现,熟练掌握链式存储结构的描述方法;3.掌握链表的基本操作(建表、插入、删除等)4. 掌握循环链表的概念,加深对链表的本质的理解。
5.掌握运用上机调试链表的基本方法三﹑实验内容:(1)创建一个链表(2)在链表中插入元素(3)在链表中删除一个元素(4)销毁链表四﹑实验步骤与程序#include <iostream.h>#include <malloc.h>typedef struct LNode{int data;struct LNode *next;}Lnode, *LinkList;//假设下面的链表均为带头结点。
void CreatLinkList(LinkList &L,int j){//建立一个链表L,数据为整数,数据由键盘随机输入。
LinkList p,q;L=(LinkList )malloc(sizeof(Lnode));L->next=NULL;q=L;cout<<"请输入一个链表:"<<endl;for(int i=0;i<j;i++){ p=(LinkList)malloc(sizeof(Lnode));cin>>p->data;p->next=q->next;q->next=p;q=p;}}int PrintLinkList(LinkList &L){//输出链表L的数据元素LinkList p;p=L->next;if(L->next==NULL){cout<<"链表没有元素!"<<endl;return 0;}cout<<"链表的数据元素为:";while(p){cout<<p->data<<" ";p=p->next;}cout<<endl;return 1;}void LinkListLengh(LinkList &L){//计算链表L的数据元素个数。
数据结构实验报告(一)线性表的应用
数据结构实验报告(⼀)线性表的应⽤实验说明数据结构实验⼀ 线性表的实验——线性表的应⽤⼀、实验⽬的通过本实验使学⽣了解线性表的⼀种简单应⽤,熟悉线性表顺序存储与链式存储的特性,特别训练学⽣编程灵活控制链表的能⼒,为今后编程控制更为复杂的数据结构奠定基础。
⼆、实验内容1.⽤顺序表和链表分别分别编程实现教材中例⼦2-1与2-2。
要求:(1)只能⽤C语⾔编程实现;(2)完全保持书中算法2.1与算法2.2形式,不允许有任何变化,除⾮语法上不允许;所调⽤各函数参照书中19页的功能描述,其中函数名、参数个数及性质、函数功能必须与书中完全⼀致,不能有变化。
2.利⽤线性表表⽰⼀元多项式完成多项式的加、减、乘、求导、求值运算。
要求:(1)输⼊的⼀元多项式可以采⽤只输⼊各项的系数与指数这种简化的⽅式。
如对于多项式2x2+6x5,输⼊可为: 2,2 6,5 这样的简单形式。
(2)遇到有消项时应当处理,如2x2+6x5与3x2-6x5进⾏相加时,结果为5*x^2。
(3)当给定x的值时,能计算表达式相加或相减的结果。
(4)操作的结果放⼊⼀个新线性表中,原来的两个表达式存储表⽰不变,也可以不是产⽣新的线性表,⽽是将两上线性表合并为⼀个。
(5)要求程序功能模块划分合理(每个函数功能单⼀、可重⽤性好),使⽤空间尽可能少,算法尽可能⾼效。
实验报告1.实现功能描述使⽤线性表表⽰⼀元多项式完成多项式的加、减,乘,求导、求值运算。
2.⽅案⽐较与选择(1)因为使⽤的是线性表,所以主要⽅案有数组法和链表法。
(2)从时间复杂度来说,使⽤数组法更优;从空间复杂度来说,链表法更优。
因为数组法是指定好空间的,若式⼦⼤⼩超出设置⼤⼩,那程序必然出错;若式⼦⼤⼩⼩于设置⼤⼩,那就意味着有多余的空间被浪费了。
综合来讲,若计算式⼦较为庞⼤,使⽤链表法更佳;相反,若计算式⼦较⼩,数组法更佳。
3.设计算法描述(1)单个项式的数据存储使⽤了结构体,数组法是在⼀个结构体中定义两个⼀维数组;链表法是通过⼀个结构体作为⼀个节点,通过next指针连接起来。
《数据结构》非线性结构实验报告一
《数据结构》非线性结构实验报告 一、实验目的:1.树是一种重要的非线性数据结构,要求掌握二叉树的两种基本的存储结构,及各种操作的算法实现(建立、遍历)以及应用。
2.以递归算法的设计方法以及二叉树的应用作为重点。
3.掌握有向图和无向图的概念;掌握邻接矩阵和邻接链表建立图的存储结构;掌握DFS 及BFS 对图的遍历操作。
4.采用邻接矩阵和邻接链表作为图的存储结构,完成有向图和无向图的DFS 和BFS 操作。
二、实验内容:1. 按先序次序输入二叉树中结点的值,建立一棵以二叉链表作存储结构的二叉树(结合“扩展先序遍历序列”创建如下图所示二叉树),然后按先序、中序、后序顺序分别遍历这棵二叉树。
2. 利用二叉树的遍历算法,实现如上图所示二叉树的叶子结点个数和深度。
3. 已知某系统在通信联络中可能出现8种字符,其概率分别为0.05、0.29、0.07、0.08、0.14、0.23、0.03和0.11,试编写程序实现以下要求:(1)构造这8种字符概率的哈夫曼树。
(2)求出这8种字符的哈夫曼编码。
4.已知一个有向图的顶点集V 和边集G 分别为:V={0,1,2,3,4,5,6,7,8};E={<0,2>,<1,3>,<1,4>,<2,4>,<2,5>,<3,6>,<3,7>,<4,7>,<4,8>,<5,7>,<6,7>,<7,8>}(1)编写程序建立该图的邻接矩阵存储。
(2)编写程序建立该图的邻接表存储。
(3)基于上图所建的存储结构,编写实现深度优先搜索算法和广度优先搜索算法。
AB FE C DPreOrder(bt->lchild);visit(bt);PreOrder(bt->rchild);}}void PostOrder(BiTree bt) //后序遍历{if (bt != NULL){PreOrder(bt->lchild);PreOrder(bt->rchild);visit(bt);}}int main(){char str[N];BiTree bt;printf("请输入二叉树(扩展先序遍历序列):");gets(str);bt = CreatBiTree(str);printf("二叉树先序遍历为:\n");PreOrder(bt);printf("\n");printf("二叉树中序遍历为:\n");InOrder(bt);printf("\n");printf("二叉树后序遍历为:\n");PostOrder(bt);return 0;}运行结果:2、源程序:#include<stdio.h>#include<stdlib.h>#define N 100printf("二叉树的叶子节点数为:%d\n", BitreeLeaf(bt));return 0;}运行结果:3、源程序:#define _CRT_SECURE_NO_W ARNINGS#include <stdio.h>#include <stdlib.h>#include <string.h>#define MAXSBIT 10#define MAXV ALUE 1000typedef char** HCode;typedef struct HNode{int weight;int parent, lchild, rchild;}HNode, *HTree;HTree HuffmanTree(int* w, int n){int m, m1, m2, x1, x2, i, j;HTree ht;HNode* p;if (n <= 1) return NULL;m = 2 * n - 1;ht = (HNode*)malloc(m * sizeof(HNode));if (ht == NULL) return ht;for (p = ht, i = 0; i < n; ++i, ++p, ++w){p->weight = *w; p->lchild = -1; p->rchild = -1;p->parent = -1;}for (; i < m; ++i, ++p){p->weight = 0; p->lchild = -1; p->rchild = -1;{int w[8] = { 5,29,7,8,14,23,3,11 };int i;HTree ht;HCode HC;ht = HuffmanTree(w, 8);HC = HuffmanCoding(ht, 8);for (i = 0; i < 8; i++)printf("%s\n", HC[i]);return 0;}运行结果:4、源程序:#include<stdio.h>#include<stdlib.h>#define FALSE 0#define TRUE 1#define MaxVertexNum 20typedef int BOOLE;BOOLE visited[MaxVertexNum];typedef struct{int vexs[MaxVertexNum];int edges[MaxV ertexNum][MaxVertexNum];int n, e;}MGraph;typedef struct node{int adjvex;struct node* next;}EdgeNode;typedef struct vnode{int vertex;DFSTraverseAL(G);printf("该图的广度优先遍历为:\n\n");BFSTraverseAL(G);}int main(){int x;do{printf("*************请选择你想要的存储方式************\n");printf("******************1.邻接矩阵 2.邻接表*********\n");scanf_s("%d", &x);} while (!(x <= 2 && x >= 1));switch (x){case 1: UseMGraph();break;case 2: UseALGraph();break;}return 0;}运行结果:。
数据结构实验报告-基于字符串模式匹配算法的病毒感染检测问题
《数据结构》实验报告
abcd abcde abc def
00 输出结果为:
YES
NO 四、分析过程
在主函数中利用键盘输入 human[ ]、virus[ ],即 cin>>human>>virus; ,输入时要注意模 式串 virus 的长度不要超过主串 human 的长度。
调用 BF 子函数,输入的两个实参会送到 BF 算法里进行比较,当比较次数小于各自的长 度 时 , 开 始 匹 配 , 即 while(i<strlen(human)&&j<strlen(virus)) 。 如 果 模 式 串 和 主 串 相 同 human[i]==virus[j]时,i 和 j 都要加 1,否则 i=i-j+1; j=0;。当 j 等于 virus 的长度时,说明匹 配成功,令输出返回值 1;否则返回值为 0。
实验时间 实验地点 指导教师
年月日 电气楼 308
实验项目
实验类别
实 验 目 的 及 要 求
基于字符串模式匹配算法的病毒感染检测问题
基础实验
实验学时
4 学时
实验目的: 1.掌握字符串的顺序存储表示方法 2.掌握字符串模式匹配算法 BF 算法或 KMP 算法的实现
实验要求: 输入多组数据,每组数据占 1 行,输入 0 0 时结束输入;每组数据输
BF 算法的基本思想是:从主串的第 pos 个字符起与模式串的第一个字符比较,若相等, 则继续逐个比较后续字符;否则从主串的下一个字符起再重新和模式串进行比较。直至模式 串中的每一个字符和主串中的一个连续字符序列相同,则称匹配成功,否则不成功。
(1)首先全局定义了两个一定长度的数组用来存储人类和病毒的 DNA,分别是 human[100] 和 virus[100]。分别用 i 和 j 来指示主串 human 和模式串 virus 当前正待比较的字符位置。
数据结构实验报告(实验)
深 圳 大 学 实 验 报 告课程名称: 数据结构实验与课程设计 实验项目名称: 实验一:顺序表的应用 学院: 计算机与软件学院 专业: 指导教师: **报告人: 文成 学号: ********** 班级: 5 实验时间: 2012-9-17实验报告提交时间: 2012-9-24教务部制一、实验目的与要求:目的:1.掌握线性表的基本原理2.掌握线性表地基本结构3.掌握线性表地创建、插入、删除、查找的实现方法要求:1.熟悉C++语言编程2.熟练使用C++语言实现线性表地创建、插入、删除、查找的实现方法二、实验内容:Problem A: 数据结构——实验1——顺序表例程Description实现顺序表的创建、插入、删除、查找Input第一行输入顺序表的实际长度n第二行输入n个数据第三行输入要插入的新数据和插入位置第四行输入要删除的位置第五行输入要查找的位置Output第一行输出创建后,顺序表内的所有数据,数据之间用空格隔开第二行输出执行插入操作后,顺序表内的所有数据,数据之间用空格隔开第三行输出执行删除操作后,顺序表内的所有数据,数据之间用空格隔开第四行输出指定位置的数据Sample Input611 22 33 44 55 66888 352Sample Output11 22 33 44 55 6611 22 888 33 44 55 6611 22 888 33 55 6622HINT第i个位置是指从首个元素开始数起的第i个位置,对应数组内下标为i-1的位置Problem B: 数据结构——实验1——顺序表的数据交换Description实现顺序表内的元素交换操作Input第一行输入n表示顺序表包含的·n个数据第二行输入n个数据,数据是小于100的正整数第三行输入两个参数,表示要交换的两个位置第四行输入两个参数,表示要交换的两个位置Output第一行输出创建后,顺序表内的所有数据,数据之间用空格隔开第二行输出执行第一次交换操作后,顺序表内的所有数据,数据之间用空格隔开第三行输出执行第二次交换操作后,顺序表内的所有数据,数据之间用空格隔开注意加入交换位置的合法性检查,如果发现位置不合法,输出error。
数据结构实验报告--
数据结构实验报告--实验一、线性表的实现线性表是常用的数据结构之一,其中最常用的是顺序存储结构。
本实验使用C语言实现了顺序存储结构的线性表。
首先,定义了一个结构体来表示线性表:```#define MAXSIZE 100 //线性表最大长度typedef struct {int data[MAXSIZE]; //存放线性表元素int length; //线性表当前长度} SqList; //线性表类型定义```其中,data数组存放线性表元素,length表示线性表当前长度。
接着,定义了三个基本操作:1. 初始化线性表```void InitList(SqList *L) {L->length = 0;}```2. 插入元素```bool ListInsert(SqList *L, int i, int e) {if (i < 1 || i > L->length + 1) { //插入位置不合法}if (L->length >= MAXSIZE) { //线性表已满return false;}for (int j = L->length; j >= i; j--) { //将第i个位置之后的所有元素后移一位L->data[j] = L->data[j - 1];}L->data[i - 1] = e; //将元素e插入到第i个位置L->length++; //线性表长度加1return true;}```3. 删除元素以上三个操作就是线性表的基本操作,通过这三个操作就能完成线性表的所有操作。
实验二、栈和队列的实现2.1 栈的实现栈是一种后进先出(Last In First Out)的数据结构。
我们可以用线性表来实现栈,只需要对线性表的插入和删除操作进行限制就行了。
具体实现如下:void InitStack(Stack *S) {S->top = -1; //初始化栈顶指针}bool Push(Stack *S, int e) {if (S->top == STACK_SIZE - 1) { //栈已满,无法插入元素}S->top++; //栈顶指针加1S->data[S->top] = e; //插入元素e到栈顶return true;}以上代码实现了栈的初始化、入栈和出栈操作。
数据结构课程实验报告
数据结构课程实验报告目录1. 实验简介1.1 实验背景1.2 实验目的1.3 实验内容2. 实验方法2.1 数据结构选择2.2 算法设计2.3 程序实现3. 实验结果分析3.1 数据结构性能分析3.2 算法效率比较3.3 实验结论4. 实验总结1. 实验简介1.1 实验背景本实验是数据结构课程的一次实践性操作,旨在帮助学生加深对数据结构的理解和运用。
1.2 实验目的通过本实验,学生将学会如何选择合适的数据结构来解决特定问题,了解数据结构与算法设计的关系并能将其应用到实际问题中。
1.3 实验内容本实验将涉及对一些经典数据结构的使用,如链表、栈、队列等,并结合具体问题进行算法设计和实现。
2. 实验方法2.1 数据结构选择在实验过程中,需要根据具体问题选择合适的数据结构,比如针对需要频繁插入删除操作的情况可选择链表。
2.2 算法设计针对每个问题,需要设计相应的算法来实现功能,要考虑算法的效率和实际应用情况。
2.3 程序实现根据算法设计,编写相应的程序来实现功能,并进行调试测试确保程序能够正确运行。
3. 实验结果分析3.1 数据结构性能分析在实验过程中,可以通过对不同数据结构的使用进行性能分析,如时间复杂度和空间复杂度等,以便选择最优的数据结构。
3.2 算法效率比较实验完成后,可以对不同算法在同一数据结构下的效率进行比较分析,找出最优算法。
3.3 实验结论根据实验结果分析,得出结论并总结经验教训,为后续的数据结构和算法设计提供参考。
4. 实验总结通过本次实验,学生将对数据结构与算法设计有更深入的了解,并能将所学知识应用到实际问题中,提高自己的实践能力和解决问题的能力。
数据结构实验报告-实验一顺序表、单链表基本操作的实现
数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表(1)掌握线性表的基本运算。
(2)掌握顺序存储的概念,学会对顺序存储数据结构进⾏操作。
(3)加深对顺序存储数据结构的理解,逐步培养解决实际问题的编程能⼒。
l 实验内容1、顺序表1、编写线性表基本操作函数:(1)InitList(LIST *L,int ms)初始化线性表;(2)InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素;(3)DeleteList1(LIST *L,int item)删除指定元素值的线性表记录;(4)DeleteList2(LIST *L,int rc)删除指定位置的线性表记录;(5)FindList(LIST *L,int item)查找线性表的元素;(6)OutputList(LIST *L)输出线性表元素;2、调⽤上述函数实现下列操作:(1)初始化线性表;(2)调⽤插⼊函数建⽴⼀个线性表;(3)在线性表中寻找指定的元素;(4)在线性表中删除指定值的元素;(5)在线性表中删除指定位置的元素;(6)遍历并输出线性表;l 实验结果1、顺序表(1)流程图(2)程序运⾏主要结果截图(3)程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值;rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素,返回值>=0为元素的位置,返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录,返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值,输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置:");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为:");OutputList(&LL);}while(1){printf("请输⼊查找元素值,输⼊0结束查找操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素,位置为:%d\n",r+1);}while(1){printf("请输⼊删除元素值,输⼊0结束查找操作:");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素,位置为:%d\n线性表为:",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置,输⼊0结束查找操作:");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为:");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表(1)掌握链表的概念,学会对链表进⾏操作。
数据结构实验一(完整版)
数据结构实验一:线性表实验报告#include <string.h>#include <ctype.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> // exi t()#include <iostream.h> // cout,cin// 函数结果状态代码#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1// #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK等typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSEtypedef int ElemType;#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量#define LISTINCREMENT 2 // 线性表存储空间的分配增量struct SqListElemType *elem; // 存储空间基址int length; // 当前长度int listsize; // 当前分配的存储容量(以sizeof(ElemType)为单位)};/**********************************************************/ /* 顺序表示的线性表的基本操作(12个) *//**********************************************************/ Status InitList(SqList &L){ // 操作结果:构造一个空的顺序线性表---------------1L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem)exit(OVERFLOW); // 存储分配失败L.length=0; // 空表长度为0L.listsize=LIST_INIT_SIZE; // 初始存储容量return OK;}Status DestroyList(SqList &L){ // 初始条件:顺序线性表L已存在。
数据结构实验一顺序表实验报告
数据结构实验一顺序表实验报告数据结构实验一顺序表实验报告一、实验目的顺序表是一种基本的数据结构,本次实验的目的是通过实现顺序表的基本操作,加深对顺序表的理解,并掌握顺序表的插入、删除、查找等操作的实现方法。
二、实验内容1. 实现顺序表的创建和初始化操作。
2. 实现顺序表的插入操作。
3. 实现顺序表的删除操作。
4. 实现顺序表的查找操作。
5. 实现顺序表的输出操作。
三、实验步骤1. 创建顺序表的数据结构,包括数据存储数组和记录当前元素个数的变量。
2. 初始化顺序表,将当前元素个数置为0。
3. 实现顺序表的插入操作:- 判断顺序表是否已满,若已满则输出错误信息。
- 将插入位置之后的元素依次后移一位。
- 将要插入的元素放入插入位置。
- 当前元素个数加一。
4. 实现顺序表的删除操作:- 判断顺序表是否为空,若为空则输出错误信息。
- 判断要删除的位置是否合法,若不合法则输出错误信息。
- 将删除位置之后的元素依次前移一位。
- 当前元素个数减一。
5. 实现顺序表的查找操作:- 遍历顺序表,逐个比较元素值与目标值是否相等。
- 若找到目标值,则返回该元素的位置。
- 若遍历完整个顺序表仍未找到目标值,则返回错误信息。
6. 实现顺序表的输出操作:- 遍历顺序表,逐个输出元素值。
四、实验结果经过实验,顺序表的各项操作均能正确实现。
在插入操作中,可以正确将元素插入到指定位置,并将插入位置之后的元素依次后移。
在删除操作中,可以正确删除指定位置的元素,并将删除位置之后的元素依次前移。
在查找操作中,可以正确返回目标值的位置。
在输出操作中,可以正确输出顺序表中的所有元素。
五、实验总结通过本次实验,我深入了解了顺序表的原理和基本操作,并通过实际编程实现了顺序表的各项功能。
在实验过程中,我遇到了一些问题,如如何判断顺序表是否已满或为空,如何处理插入和删除位置的合法性等。
通过查阅资料和与同学讨论,我解决了这些问题,并对顺序表的操作有了更深入的理解。
国开数据结构(本)数据结构课程实验报告(一)
国开数据结构(本)数据结构课程实验报告一、实验目的本实验旨在帮助学生掌握数据结构的基本概念,熟练掌握数据结构的基本操作,进一步提高学生的编程能力和数据处理能力。
二、实验内容1. 数据结构的基本概念在实验中,我们首先介绍了数据结构的基本概念,包括数据的逻辑结构和物理结构,以及数据结构的分类和应用场景。
2. 数据结构的基本操作接着,我们介绍了数据结构的基本操作,包括插入、删除、查找等操作,通过具体的案例和代码演示,让学生理解和掌握这些基本操作的实现原理和方法。
3. 编程实践在实验的第三部分,我们组织学生进行数据结构的编程实践,要求学生通过实际编写代码来实现各种数据结构的基本操作,加深对数据结构的理解和掌握。
三、实验过程1. 数据结构的基本概念在本部分,我们通过课堂讲解和案例分析的方式,向学生介绍了数据结构的基本概念,包括线性结构、树形结构、图形结构等,让学生对数据结构有一个整体的认识。
2. 数据结构的基本操作在这一部分,我们通过具体的案例和代码演示,向学生介绍了数据结构的基本操作,包括插入、删除、查找等操作的实现原理和方法,让学生掌握这些基本操作的具体实现。
3. 编程实践最后,我们组织学生进行数据结构的编程实践,要求他们通过实际编写代码来实现各种数据结构的基本操作,加深对数据结构的理解和掌握,同时也提高了他们的编程能力和数据处理能力。
四、实验结果与分析通过本次实验,学生们对数据结构有了更深入的理解和掌握,他们能够熟练地使用各种数据结构的基本操作,编写出高效、稳定的代码,提高了他们的编程能力和数据处理能力。
五、实验总结本实验对于学生掌握数据结构的基本概念和操作起到了很好的辅助作用,通过实际的编程实践,学生们不仅加深了对数据结构的理解和掌握,同时也提高了他们的编程能力和数据处理能力。
这对于他们今后的学习和工作都具有重要的意义。
六、参考文献1. 《数据结构与算法分析》2. 《数据结构(C语言版)》3. 《数据结构与算法》以上是我对“国开数据结构(本)数据结构课程实验报告”的详细报告,希望能够满足您的要求。
(完整版)数据结构实验报告全集
数据结构实验报告全集实验一线性表基本操作和简单程序1.实验目的(1)掌握使用Visual C++ 6.0上机调试程序的基本方法;(2)掌握线性表的基本操作:初始化、插入、删除、取数据元素等运算在顺序存储结构和链表存储结构上的程序设计方法。
2.实验要求(1)认真阅读和掌握和本实验相关的教材内容。
(2)认真阅读和掌握本章相关内容的程序。
(3)上机运行程序。
(4)保存和打印出程序的运行结果,并结合程序进行分析。
(5)按照你对线性表的操作需要,重新改写主程序并运行,打印出文件清单和运行结果实验代码:1)头文件模块#include iostream.h>//头文件#include<malloc.h>//库头文件-----动态分配内存空间typedef int elemtype;//定义数据域的类型typedef struct linknode//定义结点类型{elemtype data;//定义数据域struct linknode *next;//定义结点指针}nodetype;2)创建单链表nodetype *create()//建立单链表,由用户输入各结点data域之值,//以0表示输入结束{elemtype d;//定义数据元素dnodetype *h=NULL,*s,*t;//定义结点指针int i=1;cout<<"建立一个单链表"<<endl;while(1){cout <<" 输入第"<< i <<"结点data域值:";cin >> d;if(d==0) break;//以0表示输入结束if(i==1)//建立第一个结点{h=(nodetype*)malloc(sizeof(nodetype));//表示指针hh->data=d;h->next=NULL;t=h;//h是头指针}else//建立其余结点{s=(nodetype*) malloc(sizeof(nodetype));s->data=d;s->next=NULL;t->next=s;t=s;//t始终指向生成的单链表的最后一个节点}i++;}return h;}3)输出单链表中的元素void disp(nodetype*h)//输出由h指向的单链表的所有data域之值{nodetype *p=h;cout<<"输出一个单链表:"<<endl<<" ";if(p==NULL)cout<<"空表";while(p!=NULL){cout<<p->data<<" ";p=p->next;}cout<<endl;}4)计算单链表的长度int len(nodetype *h)//返回单链表的长度{int i=0;nodetype *p=h;while(p!=NULL){p=p->next;i++;}return i;}5)寻找第i个节点nodetype *find(nodetype *h,int i)//返回第i个节点的指针{nodetype *p=h;int j=1;if(i>len(h)||i<=0)return NULL;//i上溢或下溢celse{while (p!=NULL&&j<1)//查找第i个节点,并由p指向该节点{j++;p=p->next;}return p;} }6)单链表的插入操作nodetype *ins(nodetype *h,int i,elemtype x)//在单链表head中第i个节点//(i>=0)之后插入一个data域为x的节点{nodetype *p,*s;s=(nodetype*)malloc(sizeof(nodetype));//创建节点ss->data=x;s->next=NULL;if(i==0)//i=0:s作为该单链表的第一个节点{s->next=h;h=s;}else{p=find(h,i);//查找第i个节点,并由p指向该节点if(p!=NULL){s->next=p->next;p->next=s;}return h;}}7)单链表的删除操作nodetype *del(nodetype *h,int i)//删除第i个节点{nodetype *p=h, *s;int j=1;if(i==1)//删除第1个节点{h=h->next;free(p);}else{p=find(h,i-1);//查找第i-1个节点,并由p指向该节点 if(p!=NULL&&p->next!=NULL){s=p->next;//s指向要删除的节点p->next=s->next;free(s);}else cout<<"输入i的值不正确"<<endl;}return h;}8)释放节点空间void dispose(nodetype *h)//释放单链表的所有节点占用的空间{nodetype *pa=h,*pb;if(pa!=NULL){pb=pa->next;if(pb==NULL)//只有一个节点的情况free(pa);else{while (pb!=NULL)//有两个及以上节点的情况{free(pa);pa=pb;pb=pb->next;}free(pa);}}}9)主程序模块:#include"slink.h"//包含头文件slinkvoid main(){nodetype *head;//定义节点指针变量head=create();//创建一个单链表disp(head);//输出单链表cout<<"单链表长度:"<<len(head)<<endl;ins(head, 2,0);//在第二个节点之后插入以0为元素的节点 disp(head);//输出新链表del(head,2);//删除第二个节点disp(head);//输出新链表}5.实验结果建立一个单链表:输入第1结点data域值:1输入第2结点data域值:2输入第3结点data域值:3输入第4结点data域值:4输入第5结点data域值:5输入第6结点data域值:6输入第7结点data域值:7输入第8结点data域值:8输入第9结点data域值:9输入第10结点data域值0:输出一个单链表:1 2 3 4 5 6 7 8 9单链表长度:9输出一个单链表:1 02345678 9输出一个单链表:1 2 3 4 5 6 7 8实验二顺序栈的实现1.实验目的掌握顺序栈的基本操作:初始化栈、判栈空否、入栈、出栈、取栈顶数据元素等运算以及程序实现方法。
数据结构实验报告1线性表的顺序存储结构
数据结构实验报告1线性表的顺序存储结构一、实验目的本次实验的主要目的是深入理解线性表的顺序存储结构,并通过编程实现其基本操作,包括创建线性表、插入元素、删除元素、查找元素以及输出线性表等。
通过实际操作,掌握顺序存储结构的特点和优势,同时也了解其在不同情况下的性能表现。
二、实验环境本次实验使用的编程语言为C++,编译环境为Visual Studio 2019。
三、实验原理1、线性表的定义线性表是由 n(n≥0)个数据元素组成的有限序列。
在顺序存储结构中,线性表的元素存储在一块连续的存储空间中,通过数组来实现。
2、顺序存储结构的特点存储密度高,无需额外的指针来表示元素之间的关系。
可以随机访问表中的任意元素,时间复杂度为 O(1)。
插入和删除操作需要移动大量元素,平均时间复杂度为 O(n)。
四、实验内容及步骤1、定义线性表的数据结构```cppdefine MAX_SIZE 100 //定义线性表的最大长度typedef struct {int dataMAX_SIZE; //存储线性表元素的数组int length; //线性表的当前长度} SeqList;```2、初始化线性表```cppvoid InitList(SeqList L) {L>length = 0; //初始时线性表长度为 0}```3、判断线性表是否为空```cppbool ListEmpty(SeqList L) {return (Llength == 0);}```4、求线性表的长度```cppint ListLength(SeqList L) {return Llength;}```5、按位查找操作```cppint GetElem(SeqList L, int i) {if (i < 1 || i > Llength) {printf("查找位置不合法!\n");return -1;}return Ldatai 1;}```6、按值查找操作```cppint LocateElem(SeqList L, int e) {for (int i = 0; i < Llength; i++){if (Ldatai == e) {return i + 1;}}return 0; //未找到返回 0}```7、插入操作```cppbool ListInsert(SeqList L, int i, int e) {if (L>length == MAX_SIZE) {//表已满printf("表已满,无法插入!\n");return false;}if (i < 1 || i > L>length + 1) {//插入位置不合法printf("插入位置不合法!\n");return false;}for (int j = L>length; j >= i; j) {//移动元素L>dataj = L>dataj 1;}L>datai 1 = e; //插入元素L>length++;//表长加 1return true;}```8、删除操作```cppbool ListDelete(SeqList L, int i) {if (L>length == 0) {//表为空printf("表为空,无法删除!\n");return false;}if (i < 1 || i > L>length) {//删除位置不合法printf("删除位置不合法!\n");return false;}for (int j = i; j < L>length; j++){//移动元素L>dataj 1 = L>dataj;}L>length; //表长减 1return true;}```9、输出线性表```cppvoid PrintList(SeqList L) {for (int i = 0; i < Llength; i++){printf("%d ", Ldatai);}printf("\n");}```10、测试用例```cppint main(){SeqList L;InitList(&L);ListInsert(&L, 1, 10);ListInsert(&L, 2, 20);ListInsert(&L, 3, 30);ListInsert(&L, 4, 40);ListInsert(&L, 5, 50);printf("线性表的长度为:%d\n", ListLength(L));printf("查找第 3 个元素:%d\n", GetElem(L, 3));int loc = LocateElem(L, 30);if (loc) {printf("元素 30 的位置为:%d\n", loc);} else {printf("未找到元素 30\n");}ListDelete(&L, 3);printf("删除第 3 个元素后的线性表:");PrintList(L);return 0;}```五、实验结果及分析1、实验结果成功创建并初始化了线性表。
数据结构实验报告一-约瑟夫环问题
实验1约瑟夫环问题1.需求分析(1)输入的形式和输入值的范围:每一次输入的值为两个正整数,中间用逗号隔开。
若分别设为n,m,则输入格式为:“n,m”。
不对非法输入做处理,即假设输入都是合法的。
(2)输出的形式:输出格式1:在字符界面上输出这n个数的输出序列输出格式2:将这n个数的输出序列写入到文件中(3)程序所能达到的功能:对于输入的约瑟夫环长度n和间隔m,输出约瑟夫环的出列顺序。
(4)测试数据:包括正确的输入及其输出结果和含有错误的输入及其输出结果。
正确:输入:10,3输出:3 6 9 2 7 1 8 5 10 4输入:41,3输出:3 6 9 12 15 18 21 24 27 30 33 36 39 1 5 10 14 19 23 28 32 37 41 7 13 20 2634 40 8 17 29 38 11 25 2 22 4 35 16 31错误:输入:10 3输出:6 8 7 1 3 4 2 9 5 102.概要设计(1)抽象数据类型的定义:为实现上述程序的功能,可以用整数存储用户的输入。
并将用户输入的值存储于线性表中。
线性表ADT定义如下:ADT list数据对象:整形数据关系:线性关系,即<ai,ai+1>(0≤a<n)。
基本操作:bool remove(int &elem)//移除一个元素,被移除的元素赋给elem//如果操作成功,返回true,否则返回falsebool isEmpty()//判断数组的元素是否清空,空返回true,否则返回falsebool setPos(int place)//设置当前元素的位置,设置成功返回true,否则返回falseint getLength()//获取数组的实际长度(2)算法的基本思想:约瑟夫环问题中的数据是人所在的位置,而这种数据是存在“第一元素、最后元素”,并且存在“唯一的前驱和后继的”,符合线性表的特点。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
云南大学
数据结构实验报告
第一次实验
学号:
姓名:
一、实验目的
1、复习变量、数据类型、语句、函数;
2、掌握函数的参数和值;
3、了解递归。
二、实验内容
1、(必做题)采用函数统计学生成绩:输入学生的成绩,计算并输出这些学生的最低分、最高分、平均分。
2、(必做题)采用递归和非递归方法计算k阶裴波那契序列的第n项的值,序列定义如下:f0=0, f1=0, …, fk-2=0, fk-1=1, fn= fn-1+fn-2+…+fn-k(n>=k) 要求:输入k(1<=k<=5)和n(0<=n<=30),输出fn。
3、(选做题)采用递归和非递归方法求解汉诺塔问题,问题描述如下:有三根柱子A、B、C,在柱子A上从下向上有n个从大到小的圆盘,在柱子B和C上没有圆盘,现需将柱子A上的所有圆盘移到柱子C上,可以借助柱子B,要求每次只能移动一个圆盘,每根柱子上的圆盘只能大的在下,小的在上。
要求:输入n,输出移动步骤。
三、算法描述
(采用自然语言描述)
1、①先输入需统计的学生人数。
②根据学生人数输入成绩,计算成绩总和和平均分。
③比较成绩大小,得出最低分和最高分。
④输出计算结果。
2、⑴①写出不同情况下求k阶裴波那契序列的第n项的值的递归函数。
②输入k和n。
③输出计算结果。
四、详细设计
(画出程序流程图)
1、
2、⑴
五、程序代码
(给出必要注释)
1、
#include <stdio.h>
#include <stdlib.h>
#define N 100 /*先预计输入人数在0~100内,如果人数多于100再将100改成更大的数*/
void main()
{int i,x[N],a;
int max,min;
float ave,sum=0.0;
printf("请输入不多于%d的学生人数:",N);
scanf("%d",&a); /*输入学生数*/
for(i=0;i<a;i++)
{printf("请输入第个%d学生成绩(整数):",i+1);
scanf("%d",&x[i]);
sum=sum+x[i];} /*输入分数*/
ave=sum/a; /*计算平均分*/
max=x[0];
min=x[0];
for(i=0;i<a;i++)
{if(x[i]>=max)
{max=x[i];}
if(x[i]<=min)
{min=x[i];} }
printf("平均分是:%f",ave);
printf("最高分是:%d",min);
printf("最低分是:%d",max);/*输出平均分,最低分,最高分*/ return 0;
}
2、
⑴
#include <stdio.h>
#include <stdlib.h>
int k;
int Fibonacci (int n1)
{if(n1<k-1)
return 0;
else if(n1==k-1||n1==k)
return 1;
else if(n1==k+1)
return 2;
else
return (2*Fibonacci(n1-1)-Fibonacci(n1-k-1));
}
int main()
{int n,fn=0;
printf("请输入整数k(大于等于1):");
scanf("%d",&k);
printf("请输入整数n(大于k):");
scanf("%d",&n);
while(k==1)
{printf("f%d=1\n",n);
break;}
while(k>1)
{fn=Fibonacci(n);
printf("f%d=%d",n,fn);
break;}
return 0;
}
六、测试和结果
(给出测试用例以及测试结果)
1、
2、
七、用户手册
(告诉用户如何使用程序)
1、打开并运行程序,根据提示输入学生人数和学生成绩,每次输入后都按enter键。
2、打开并运行程序,根据提示输入k和n,每次输入后都按enter键。