淮海工学院数据结构第一次实验报告
数据结构实验一实验报告
欢迎下载
7
—
for(int i=1;i<=x;i++) {
printf(" 第%d 个学生 :\n",i); Input(&a); ListInsert(&L,i,a); } break; case 3: for(int i=1;i<=x;i++) { GetElem(&L,i,b); Output(&b); } break; case 4: char s[20]; printf(" 请输入要查找的学生姓名 :"); scanf("%s",s); if(Search(L,s,p)) Output(&(p->data)); else puts(" 对不起,查无此人 ");
void Input(ElemType *e) {
欢迎下载
5
—
printf(" 姓名 :"); scanf("%s",e->name); printf(" 学号 :"); scanf("%s",e->num); printf(" 成绩 :"); scanf("%lf",&e->grade); printf(" 输入完成 \n\n"); }
puts(" 请选择 :"); scanf("%d",&choose); switch(choose) {
case 1: if(InitList(p)) printf(" 成功建立链表 \n\n"); else printf(" 链表建立失败 \n\n"); break;
图状数据结构实验
Graphicmap[i].link =NULL;
}
printf("某项目的开始到结束在图中的节点输入<vi,vj,dut>\n");
printf("如:3,4,9 回车表示第三节点到第四节点之间的活动用了9个单位时间\n");
for(k=0;k<activenumber;k++)
while(p)
{
k=p->adjvex ;
Graphicmap[k].id --;
if(ve[j]+p->dut >ve[k])
ve[k]=ve[j]+p->dut ;
if(Graphicmap[k].id ==0)
topologystack[++rear]=k;
p=p->next ;
}
}
if(m<projectnumber)
for(i=0;i<projectnumber;i++)
{
if(Graphicmap[i].id==0)
{
topologystack[++rear]=i;
m++;
}
}
while(front!=rear)
{
front++;
j=topologystack[front];
m++;
p=Graphicmap[j].link ;
for(j=0;j<projectnumber;j++)
{
p=Graphicmap[j].link;
数据结构实验报告(实验一)
深圳大学实验报告
课程名称:数据结构实验与课程设计
实验项目名称:实验一:顺序表的应用
学院:计算机与软件学院
专业:
指导教师:蔡平
报告人:文成学号: 2011150259 班级:
5
实验时间: 2012-9-17 实验报告提交时间: 2012-9-24
教务部制
return 0;
}
四、实验结果及数据处理分析:A:
实验基本达到实验要求
B:
实验基本达到实验要求
C:
实验基本达到实验要求
D:
实验基本达到实验要求
五、实验结论与体会:
从这个实验中我学会了线性表一些基本操作,例如插入、查找和删除。
也复习了一边C++语言程序的规。
原先试了很多次都是出现错误,最后才发现太久没编程,犯了很多低级错误,从中体会到编程是需要时间和耐心的。
要求挺简单的,就是如此简单的插入、查找、删除、循环移位等。
程序写完了,但是还发现程序中还有许多不完善的地方、不严谨的地方,如异常
2、教师批改学生实验报告时间应在学生提交实验报告时间后10日。
数据结构实验报告
数据结构实验报告
本次数据结构实验的任务主要包括两部分,分别是学习使用链表数据结构和掌握链表排序算法。
在此基础上,我们完成了一组关于链表基本操作和排序算法的实验。
实验一:链表基本操作
在这个实验中,我们学习了链表的插入、删除、查找等基本操作。
链表的插入和删除操作是通过一个链表节点来实现的。
链表节点包括一个数据域和一个指向下一个节点的指针域。
通过修改指针域,我们就可以实现节点的插入和删除操作。
具体来说,我们编写了一个基本的链表程序,其中包括链表头指针初始化、链表节点插入、链表节点删除、查找指定节点等操作。
通过对程序的调试和功能测试,我们验证了链表操作的正确性。
实验二:链表排序算法
在这个实验中,我们学习了链表排序算法,并编写了链表的快速排序和归并排序两种算法。
快速排序是一种分治思想的排序算法,通过选择一个基准元素,分别将小于和大于基准元素的元素分别放在它的左右两边,再递归地对左右两个子序列进行排序,最终得到有序序列。
归并排序是另一种经典的排序算法,它利用归并思想,将两个有序序列合并成一个更大的有序序列,这个过程不断重复,最终得到完整的有序序列。
通过实现这两种排序算法,并在大样本数据下进行测试,我们验证了算法的正确性和效率。
实验总结:
通过本次实验,我们深入学习了链表数据结构的相关基本操作和排序算法的实现原理。
同时,在实际编程实践中,我们也掌握了链表程序的调试、测试和优化技术。
这些都是我们今后从事软件开发工作需要掌握的重要技能,在这个方面的积累将会对我们有很大帮助。
淮海工学院大数据结构第一次实验资料报告材料
淮海工学院计算机科学系实验报告书课程名:《数据结构》题目:线性数据结构试验班级:软嵌151学号: 2015123352姓名:吉线性表实验报告要求1目的与要求:1)掌握线性表数据结构的基本概念和抽象数据类型描述;2)熟练掌握线性表数据结构的顺序和链式存储存表示;3)熟练掌握线性表顺序存储结构的基本操作算法实现;4)熟练掌握线性表的链式存储结构的基本操作算法实现;5)掌握线性表在实际问题中的应用和基本编程技巧;6)按照实验题目要求独立正确地完成实验容(提交程序清单及相关实验数据与运行结果);7)按照报告格式和容要求,认真书写实验报告,并于下周周二前统一提交实验报告电子版文档(每次实验全体同学必须提交实验报告电子版,实验报告文档文件命名方式:+学号+数据结构第X次实验报告)提交给学委,而后由学委以班为单位统一打包(包文件名为:软件14X 班-数据结构第X次实验报告)用发给老师;提交纸质报告(每班每次收5份,学委安排,保证每学期每个同学至少提交一次)一起提交给老师。
每次提交电子文档时,学委务必统计和上报未交报告人数和具体;凡逾期不交报告者,不再推迟提交,一律按照旷交处理。
8)积极开展实验组组交流和辅导,严禁直接复制和剽窃他人实验成果,一旦发现严肃处理;9)上实验课前,要求每个同学基本写好程序,并存储在自己的U盘上,用于实验课堂操作时调试和运行。
2实验容或题目(在一个主程序中实现全部题目容)一、顺序表的基本操作实现实验要求:数据元素类型ElemType取整型int。
按照顺序存储结构实现如下算法:1)创建任意整数线性表(即线性表的元素值随机在键盘上输入)的顺序存储结构(即顺序表),长度限定在25之;2)打印/显示(遍历)该线性表(依次打印/显示出表中元素值);3)在顺序表中查找第i个元素,并返回其值;4)在顺序表第i个元素之前插入一已知元素;5)在顺序表中删除第i个元素;6)求顺序表中所有元素值(整数)之和;二、链表(带头结点)基本操作实验要求:数据元素类型ElemType取字符型char。
数据结构实验报告一
数据结构实验报告一数据结构实验报告一一、引言数据结构是计算机科学中非常重要的一门课程,它研究的是数据的组织、存储和管理方式。
在本次实验中,我们将学习并实践一些常用的数据结构,包括数组、链表和栈。
通过实验,我们将深入理解这些数据结构的原理和应用。
二、实验目的本次实验的目的是通过编写代码实现一些常用的数据结构,并测试它们的功能和性能。
通过实际操作,我们将掌握这些数据结构的基本操作和使用方法。
三、实验过程1. 数组数组是一种线性数据结构,它由一组连续的存储单元组成。
在本次实验中,我们将实现一个动态数组,它可以根据需要自动调整大小。
我们首先定义一个数组类,包含插入、删除和查找等基本操作。
然后,我们编写测试代码,验证数组的功能和性能。
2. 链表链表是另一种常用的数据结构,它由一系列节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。
在本次实验中,我们将实现一个单向链表。
我们首先定义一个节点类,然后定义一个链表类,包含插入、删除和查找等基本操作。
最后,我们编写测试代码,验证链表的功能和性能。
3. 栈栈是一种特殊的线性数据结构,它只能在一端进行插入和删除操作。
栈的特点是后进先出(LIFO)。
在本次实验中,我们将实现一个栈。
我们首先定义一个栈类,包含入栈、出栈和查看栈顶元素等基本操作。
然后,我们编写测试代码,验证栈的功能和性能。
四、实验结果通过实验,我们成功实现了动态数组、单向链表和栈的基本操作。
我们编写了测试代码,并对这些数据结构的功能和性能进行了验证。
实验结果表明,这些数据结构在不同场景下都有很好的表现,并且可以满足我们的需求。
五、实验总结本次实验让我们更加深入地理解了数据结构的原理和应用。
通过实际编写代码并进行测试,我们掌握了数组、链表和栈等常用数据结构的基本操作和使用方法。
实验过程中,我们遇到了一些问题,但通过不断的调试和优化,最终成功解决了这些问题。
通过本次实验,我们不仅提高了编程能力,也增强了对数据结构的理解和应用能力。
数据结构的实验报告
一、实验目的本次实验旨在让学生掌握数据结构的基本概念、逻辑结构、存储结构以及各种基本操作,并通过实际编程操作,加深对数据结构理论知识的理解,提高编程能力和算法设计能力。
二、实验内容1. 线性表(1)顺序表1)初始化顺序表2)向顺序表插入元素3)从顺序表删除元素4)查找顺序表中的元素5)顺序表的逆序操作(2)链表1)创建链表2)在链表中插入元素3)在链表中删除元素4)查找链表中的元素5)链表的逆序操作2. 栈与队列(1)栈1)栈的初始化2)入栈操作3)出栈操作4)获取栈顶元素5)判断栈是否为空(2)队列1)队列的初始化2)入队操作3)出队操作4)获取队首元素5)判断队列是否为空3. 树与图(1)二叉树1)创建二叉树2)遍历二叉树(前序、中序、后序)3)求二叉树的深度4)求二叉树的宽度5)二叉树的镜像(2)图1)创建图2)图的深度优先遍历3)图的广度优先遍历4)最小生成树5)最短路径三、实验过程1. 线性表(1)顺序表1)初始化顺序表:创建一个长度为10的顺序表,初始化为空。
2)向顺序表插入元素:在顺序表的第i个位置插入元素x。
3)从顺序表删除元素:从顺序表中删除第i个位置的元素。
4)查找顺序表中的元素:在顺序表中查找元素x。
5)顺序表的逆序操作:将顺序表中的元素逆序排列。
(2)链表1)创建链表:创建一个带头结点的循环链表。
2)在链表中插入元素:在链表的第i个位置插入元素x。
3)在链表中删除元素:从链表中删除第i个位置的元素。
4)查找链表中的元素:在链表中查找元素x。
5)链表的逆序操作:将链表中的元素逆序排列。
2. 栈与队列(1)栈1)栈的初始化:创建一个栈,初始化为空。
2)入栈操作:将元素x压入栈中。
3)出栈操作:从栈中弹出元素。
4)获取栈顶元素:获取栈顶元素。
5)判断栈是否为空:判断栈是否为空。
(2)队列1)队列的初始化:创建一个队列,初始化为空。
2)入队操作:将元素x入队。
3)出队操作:从队列中出队元素。
1实验一创建数据库、数据表淮海工学院
淮海工学院计算机工程学院实验报告书
课程名《数据库原理与应用A 》
题目:实验一创建数据库、数据表
班级:******
学号:************
姓名:*****
《数据库原理与应用A 》实验报告- 1 - 1、实验内容或题目
数据库基本语句
2、实验目的与要求
(1) 掌握在图形界面环境下创建数据库的方法,完成书上School数据库的创建;
(2) 掌握在图形界面环境下创建数据表的方法,完成书上5张表的创建及录入对应的数据。
3、实验步骤与源程序
⑴实验步骤
熟悉Sql server 2005客户端图形界面的使用;
练习在图形界面环境下创建数据库、数据表的方法
完成实验报告
⑵操作步骤
4、测试数据与实验结果(可以抓图粘贴)
5、结果分析与实验体会。
查找、排序的应用实验1
淮海工学院计算机科学系实验报告书课程名:《数据结构》题目:查找、排序的应用实验班级:软件081学号:110831123姓名:XX排序、查找的应用实验报告要求1目的与要求:1)查找、排序是日常数据处理过程中经常要进行的操作和运算,掌握其算法与应用对于提高学生数据处理能力和综合应用能力显得十分重要。
2)本次实验前,要求同学完整理解有关排序和查找的相关算法和基本思想以及种算法使用的数据存储结构;3)利用C或C++语言独立完成本次实验内容或题目,程序具有良好的交互性(以菜单机制实现实验程序的交互运行)和实用性;4)本次与第七次实验已合二为一,实验结果在机房现场验收和评分,希望同学们认真对待,并于2009年12月20日按时提交本次实验报告(含电子和纸质报告),任何同学不得拖延。
5)如果验收时间紧张,不能再正课时间完成者,由老师择机决定另行通知专门验收时间。
凡无故不主动或拖延验收者,均按照不及格处理。
5)认真书写实验报告(包括程序清单及相关实验数据与完整运行结果),并于按时提交。
2 实验内容或题目题目:对数据序列(查找表):{55,13,23,72,109,67,2,78,13}分别实现如下操作:1)顺序查找;2)分别使用直接插入排序、冒泡排序、快速排序对原纪录序列进行排序;3)对排好序的纪录序列表进行折半查找;4)利用原纪录序列建立一颗二叉排序树,并在其上实现特定关键字值结点的查找;5)按照“除留余数法”哈希构造函数和线性探测再散列的冲突处理方法创建表长为m=11的哈希表;6)实现5)创建哈希表上的查找。
7)分别简单选择排序、堆排序、链式基数排序算法对数据序列进行排序,并显示排序结果。
3 实验步骤与源程序#include <stdio.h>#include <stdlib.h>#include<malloc.h>#include <math.h>#define LIST_SIZE 20#define KEY_SIZE 6#define RADIX 10#define TRUE 1#define FALSE 0#define SUCCESS 1#define UNSUCCESS -1#define MAX 20typedef char KeyType;typedef int OtherType;typedef struct{KeyType key;OtherType other_data;}RecordType;typedef struct{KeyType key[KEY_SIZE];int type;int next;}RecordType1;typedef struct{RecordType1 R[LIST_SIZE+1];int length;int keynum;}SLinkList;typedef int PVector[RADIX];typedef struct{RecordType r[LIST_SIZE+1]; /* r[0]为工作单元 */ int length;}RecordList;//二叉排序树的创建与查找#define ENDKEY 0typedef struct node{KeyType key ; /*关键字的值*/struct node *lchild,*rchild;/*左右指针*/}BSTNode, *BSTree;/*哈希表的创建*/typedef struct{int key;int flag;//falg=1时表示有关键字,=0时表示没有关键字}Elemtype;typedef struct{Elemtype *elem;//动态分配的哈希表的首地址int sizeindex;//hashsize[sizeindex]为当前容量int count;//当前数据元素个数}HashTable;/*顺序查找*/void SeqSearch(RecordList l, KeyType k)/*在顺序表l中顺序查找其关键字等于k的元素,若找到,则函数值为该元素在表中的位置,否则为0*/{int i;l.r[0].key=k;i=l.length;while (l.r[i].key!=k) i--;if (i>=1){printf("该元素k所在的位置是:");printf("%d",i);}elseprintf("该元素不存在");}//直接插入排序void InsSort(RecordType r[], int length)/* 对记录数组r做直接插入排序,length为数组中待排序记录的数目*/{int i,j;for (i=2; i<=length; i++){r[0]=r[i]; /*将待插入记录存放到监视哨r[0]中*/j=i-1;while (r[0].key< r[j].key ) /* 寻找插入位置 */{r[j+1]= r[j];j=j-1;}r[j+1]=r[0]; /*将待插入记录插入到已排序的序列中*/}} /* InsSort *//*冒泡排序*/void BubbleSort(RecordType r[],int length)/*对记录数组r做冒泡排序,length为数组的长度*/{int x,i,n,change,j;n=length;change=TRUE;for(i=1;i<=n-1&&change;++i){change=FALSE;for(j=1;j<=n-i;++j)if(r[j].key>r[j+1].key){x=r[j].key;r[j]=r[j+1];r[j+1].key=x;change=TRUE;}}}//快速排序int Partition(RecordList &L,int low,int high) //Partition() sub-function { int pivotkey;L.r[0]=L.r[low];pivotkey=L.r[low].key;while(low<high){ while(low<high&&L.r[high].key>=pivotkey)--high;L.r[low]=L.r[high];while(low<high&&L.r[low].key<=pivotkey)++low;L.r[high]=L.r[low];}L.r[low]=L.r[0];return(low);} //Partition() endvoid Qsort(RecordList &L,int low,int high) //Qsort() sub-function{ int pivotloc;if(low<high){ pivotloc=Partition(L,low,high);Qsort(L,low,pivotloc-1);Qsort(L,pivotloc+1,high);}}void QuickSort(RecordList &L) //QuickSort() sub-function{ Qsort(L,1,L.length); //call Qsort()}/*对排好的序进行折半查找算法*/void BinSrch(RecordList l,KeyType k)/*在有序表l中折半查找其关键字等于k的元素,若找到,则函数值为该元素在表中的位置*/{int low,high,mid;low=1;high=l.length;/*置区间初值*/while(low<=high){mid=(low+high)/2;if (k==l.r[mid].key){printf("找到该元素,其位置为%d",mid);break;}/*找到待查元素*/elseif (k<l.r[mid]. key)high=mid-1;/*未找到,则继续在前半区间进行查找*/ elselow=mid+1;/*继续在后半区间进行查找*/}if(low>high) printf("没有找到该元素");}void InsertBST(BSTree *bst, KeyType key)/*若在二叉排序树中不存在关键字等于key的元素,插入该元素*/{BSTree s;if (*bst == NULL)/*递归结束条件*/{s=(BSTree)malloc(sizeof(BSTNode));/*申请新的结点s*/s-> key=key;s->lchild=NULL;s->rchild=NULL;*bst=s;}elseif (key < (*bst)->key)InsertBST(&((*bst)->lchild), key);/*将s插入左子树*/ elseif (key > (*bst)->key)InsertBST(&((*bst)->rchild), key); /*将s插入右子树*/ }void CreateBST(BSTree *bst)/*从键盘输入元素的值,创建相应的二叉排序树*/{KeyType key;*bst=NULL;scanf("%d", &key);while (key!=ENDKEY) /*ENDKEY为自定义常量*/{InsertBST(bst, key);scanf("%d", &key);}}void PreOrder(BSTree root)/*先序遍历二叉树, root为指向二叉树根结点的指针*/{if (root!=NULL){printf("%d ",root->key); /*输出结点*/PreOrder(root->lchild); /*先序遍历左子树*/PreOrder(root->rchild); /*先序遍历右子树*/}}BSTree SearchBST(BSTree bst, KeyType key)/*在根指针bst所指二叉排序树中,递归查找某关键字等于key的元素,若查找成功,返回指向该元素结点指针,否则返回空指针*/{if (!bst)return NULL;elseif (bst->key == key)return bst;/*查找成功*/elseif (bst->key > key)return SearchBST(bst->lchild, key);/*在左子树继续查找*/elsereturn SearchBST(bst->rchild, key);/*在右子树继续查找*/}BSTNode * DelBST(BSTree t, KeyType k) /*在二叉排序树t中删去关键字为k的结点*/{BSTNode *p, *f,*s ,*q;p=t;f=NULL;while(p) /*查找关键字为k的待删结点p*/{if(p->key==k ) break; /*找到则跳出循环*/f=p; /*f指向p结点的双亲结点*/if(p->key>k)p=p->lchild;elsep=p->rchild;}if(p==NULL) return t; /*若找不到,返回原来的二叉排序树*/if(p->lchild==NULL) /*p无左子树*/{if(f==NULL)t=p->rchild; /*p是原二叉排序树的根*/elseif(f->lchild==p) /*p是f的左孩子*/f->lchild=p->rchild ; /*将p的右子树链到f的左链上*/ else /*p是f的右孩子*/f->rchild=p->rchild ; /*将p的右子树链到f的右链上*/ free(p); /*释放被删除的结点p*/}else /*p有左子树*/{q=p;s=p->lchild;while(s->rchild) /*在p的左子树中查找最右下结点*/{q=s;s=s->rchild;}if(q==p)q->lchild=s->lchild ; /*将s的左子树链到q上*/ elseq->rchild=s->lchild;p->key=s->key; /*将s的值赋给p*/free(s);}return t;} /*DelBST*//*建立哈希表*/int CreatHashTable(HashTable &H,int m){int i,keys,p,len;H.elem = (Elemtype *)malloc(MAX * sizeof(Elemtype));H.sizeindex = MAX;//初始存储容量H.count=0;printf("请输入该组关键字的个数:");scanf("%d",&m);printf("请输入表长len:");scanf("%d",&len);H.sizeindex = len;for(i = 0;i < m;++i){H.elem[i].flag = 0;printf("请输入该组关键字:");for(i = 0;i < m;++i){scanf("%d",&keys);p = keys %m;while(H.elem[p].flag == 1)//处理冲突{int d=1;p = (p +d)% m;d++;}H.elem[p].key = keys;H.elem[p].flag = 1;H.count++;}for(int j=H.count;j<len;j++)H.elem[j].key=0;printf("哈希表创建完毕!\n");printf("下标关键字\n");for(i = 0;i<len;i++){printf("%d ",i);printf("%d",H.elem[i].key);printf("\n");}return SUCCESS;}void SearchHashTable(HashTable H){int keys,p;printf("请输入您要查找的关键字:\n");scanf("%d",&keys);for(int i=0;i<H.count;i++){if( keys == H.elem[i].key)//p是找到的关键字的下标{p=i;}}if(p>-1&&p<H.count){printf("查找成功!\n");printf("该关键字在哈希表中的下标为:%d \n",p); }elseprintf("查找失败,表中无此关键字!\n");/*简单选择排序*/void SelectSort(RecordType r[],int length)/*对记录数组r做简单选择排序,length为数组的长度*/{int i,j,k,x,n=length;for(i=1;i<=n-1;++i){k=i;for(j=i+1;j<=n;++j)if(r[j].key<r[k].key) k=j;if(k!=i){x=r[i].key;r[i]=r[k];r[k].key=x;}}}/*筛选算法*/void sift(RecordType r[],int k,int m)/*假设r[k..m]是以r[k]为根的完全二叉树,且分别以r[2k]和r[2k+1]为根的左右子树为大根堆,调整r[k],使整个序列r[k..m]满足堆的性质*/{int i,t,j,x,finished;t=r[k].key;x=r[k].key;i=k;j=2*i;finished=FALSE;while(j<=m&&!finished){if(j<m&&r[j].key<r[j+1].key) j=j+1;/*若存在右子树,且右子树的关键字大,则沿右分支“筛选”*/if(x>=r[j].key) finished=TRUE; /*筛选完毕*/else{r[i]=r[j];i=j;j=2*i;} /*继续筛选*/}r[i].key=t;/*r[k]填入到恰当位置*/}/*建立堆*/void crt_heap(RecordType r[],int length)/*对记录数组r建堆,length为数组的长度*/{int i,n=length;for(i=n/2;i>=1;--i) /*自第n/2个记录开始进行筛选建堆*/sift(r,i,n);}/*堆排序*/void HeapSort(RecordType r[],int length)/*对r[1..n]进行堆排序,执行本算法后,r中记录按关键字由大到小有序排列*/ {crt_heap(r,length);int i,b,n=length;for(i=n;i>=2;--i){b=r[1].key; /*将堆顶记录和堆中的最后一个记录互换*/r[1]=r[i];r[i].key=b;sift(r,1,i-1); /*进行调整,使r[1..i-1]变成堆*/}}//链式基数排序void Distribute (SLinkList *L,int i,PVector head,PVector tail){int j,p;for(j=0;j<=RADIX-1;++j)head[j]=0;p=L->R[0].next;while(p){j=L->R[p].key[i];if(head[j]==0) head[j]=p;else L->R[tail[j]].next=p;tail[j]=p;p=L->R[p].next;}}void Collect(SLinkList *L,PVector head,PVector tail){int j=0,t;while(head[j]==0)++j;L->R[0].next=head[j];t=tail[j];while(j<RADIX-1){++j;while((j<RADIX-1)&&(head[j]==0))++j;if(head[j]!=0){L->R[t].next=head[j];t=tail[j];}}L->R[t].next=0;}void RadixSort(SLinkList *L ){int n,i,d,j,x,k;printf("输入链表长度 :");scanf("%d",&(L->length));printf("输入最大位数 :");scanf("%d",&(L->keynum));PVector head,tail;n=L->length;for(i=0;i<=n-1;++i) L->R[i].next=i+1; L->R[n].next=0;printf("输入各记录 :");for(j=1;j<=L->length;j++){scanf("%d",&(L->R[j].type));}for(i=1;i<=L->length;i++){x=L->R[i].type;for(j=0;j<L->keynum;j++){L->R[i].key[j]=x%10;x=x/10;}}d=L->keynum;for(i=0;i<L->keynum;++i){Distribute(L,i,head,tail);Collect(L,head,tail);}k=0;printf("排序后为 :");while(L->R[k].next){printf("%d ",L->R[L->R[k].next].type);k=L->R[k].next;}}void main(){int i,j,select,a,flag=1,m=0;printf("1 记录序列 \n2 进行顺序查找 \n3 进行直接排序 \n4 进行冒泡排序 \n5 进行快速排序 \n6进行简单选择排序并输出 \n7进行堆排序并输出 \n");printf("\n8 进行链式基数排序并输出 \n9 对排好序的纪录序列表进行折半查找 \n10 利用原纪录序列建立一颗二叉排序树,并在其上实现特定关键字值结点的查找 \n11 建立哈希表,并对其进行查找 \n12 退出");RecordType r[20];BSTree bst,result,T;RecordList L,Q;int length,k,low;while(flag){printf("请选择:");scanf("%d",&a);switch(a){case 1:printf("请输入待排序记录的长度:"); //交互创建纪录表scanf("%d",&length);for(i=1;i<=length;i++){printf("请输入第%d个记录元素:",i);fflush(stdin);scanf("%d",&j);r[i].key = j;}printf("你输入的各元素为:");for(i=1;i<=length;i++)printf("%d ",r[i].key);printf("\n");break;case 2:printf("请输入你要查找的元素k:");fflush(stdin);scanf("%d",&k);L.length=length;for(i=1;i<=L.length;i++){L.r[i]=r[i];}SeqSearch(L,k);printf("\n");break;case 3:InsSort(r,length);printf("按直接排序后各元素为:");for(i=1;i<=length;i++)printf("%d ",r[i].key);printf("\n");break;case 4:BubbleSort(r,length);printf("按冒泡排序后各元素为:");for(i=1;i<=length;i++)printf("%d ",r[i].key);printf("\n");break;case 5:L.length=length;for(i=1;i<=L.length;i++){L.r[i]=r[i];}QuickSort(L);printf("进行快速排序后各元素为: ");for(i=1;i<=L.length;i++)printf("%d ",L.r[i].key);printf("\n");break;case 6: SelectSort(r,length);printf("按简单选择排序后各元素为:");for(i=1;i<=length;i++)printf("%d ",r[i].key);printf("\n");break;case 7: HeapSort(r,length);printf("按堆排序后各元素为:");for(i=1;i<=length;i++)printf("%d ",r[i].key);printf("\n");break;case 8: SLinkList l;RadixSort(&l);printf("\n");break;case 9:InsSort(r,length);L.length=length;for(i=1;i<=L.length;i++){L.r[i]=r[i];}printf("请输入要查找的元素:");scanf("%d",&k);BinSrch(L,k);printf("\n");break;case 10:int k;printf("建立二叉排序树,请输入序列(以0结束):\n"); CreateBST(&T);printf("先序遍历输出序列为:");PreOrder(T);printf("\n请输入要查找的元素:");fflush(stdin);scanf("%d",&k);result = SearchBST(T,k);if (result != NULL)printf("存在要查找的元素为%d\n",result->key);elseprintf("未找到!\n");result = DelBST(T,k);// getch();break;case 11:HashTable H;CreatHashTable(H,m);SearchHashTable(H);break;case 12:flag=0;}}}4 测试数据与实验结果(可以抓图粘贴)简单选择排序、堆排序与基数排序,见下图:5 结果分析与实验体会在这次试验中的第7题中前两个排序:简单选择排序与堆排序都直接从书上摘下来的,可对于基数排序,还需要自己写点,比如Order函数,在这里我没有直接调用,他表示用记录中的第i位关键字求相应队列号,而是写在了RadixSort函数中。
数据结构实验实训总结报告
一、实验背景随着计算机技术的飞速发展,数据结构作为计算机科学的重要基础,已经成为现代软件开发和数据处理的关键技术。
为了提高学生的数据结构应用能力,我们学校开设了数据结构实验实训课程。
本课程旨在通过实验实训,使学生深入理解数据结构的基本概念、性质、应用,掌握各种数据结构的实现方法,提高编程能力和解决实际问题的能力。
二、实验内容本次数据结构实验实训主要包括以下内容:1. 数据结构的基本概念和性质通过实验,使学生掌握线性表、栈、队列、串、树、图等基本数据结构的概念、性质和应用场景。
2. 数据结构的存储结构通过实验,使学生熟悉线性表、栈、队列、串、树、图等数据结构的顺序存储和链式存储方法,了解不同存储结构的优缺点。
3. 数据结构的操作算法通过实验,使学生掌握线性表、栈、队列、串、树、图等数据结构的插入、删除、查找、遍历等基本操作算法。
4. 数据结构的实际应用通过实验,使学生了解数据结构在各个领域的应用,如网络数据结构、数据库数据结构、人工智能数据结构等。
三、实验过程1. 实验准备在实验开始前,教师首先对实验内容进行讲解,使学生了解实验目的、实验步骤和实验要求。
同时,教师要求学生预习实验内容,熟悉相关理论知识。
2. 实验实施(1)线性表:通过实现线性表的顺序存储和链式存储,实现插入、删除、查找等操作。
(2)栈和队列:通过实现栈和队列的顺序存储和链式存储,实现入栈、出栈、入队、出队等操作。
(3)串:通过实现串的顺序存储和链式存储,实现串的插入、删除、查找等操作。
(4)树:通过实现二叉树、二叉搜索树、平衡二叉树等,实现树的插入、删除、查找、遍历等操作。
(5)图:通过实现图的邻接矩阵和邻接表存储,实现图的插入、删除、查找、遍历等操作。
3. 实验总结实验结束后,教师组织学生进行实验总结,总结实验过程中的收获和不足,提出改进措施。
四、实验成果通过本次数据结构实验实训,学生取得了以下成果:1. 掌握了数据结构的基本概念、性质和应用场景。
数据结构第一次实验报告
数据结构第一次实验报告实验报告:数据结构第一次实验摘要:本次实验旨在通过实践操作,加深对数据结构的理解,并掌握数据结构的基本操作。
实验中,我们使用C++编程语言实现了链表、栈和队列的相关操作,并对其进行了测试和分析。
实验结果表明,我们成功地完成为了链表、栈和队列的实现,并验证了它们的正确性和效率。
1. 引言数据结构是计算机科学中的重要基础课程,它研究数据的组织方式和存储结构,以及对数据进行操作和处理的方法。
本次实验旨在通过实践操作,加深对数据结构的理解,并掌握数据结构的基本操作。
2. 实验目的- 熟悉链表、栈和队列的基本概念;- 掌握链表、栈和队列的基本操作;- 分析链表、栈和队列的时间复杂度。
3. 实验方法3.1 链表的实现我们使用C++编程语言实现了链表的基本操作,包括创建链表、插入节点、删除节点和打印链表等。
具体实现过程如下:- 定义一个链表节点结构体,并在结构体中定义节点的数据域和指针域;- 创建链表,即定义一个头节点,并设置头节点的指针域为空;- 插入节点,即在链表中指定位置插入一个新节点;- 删除节点,即删除链表中指定位置的节点;- 打印链表,即遍历链表并输出节点的数据。
3.2 栈的实现我们使用C++编程语言实现了栈的基本操作,包括入栈、出栈和判断栈是否为空等。
具体实现过程如下:- 定义一个栈结构体,并在结构体中定义一个数组和一个指针top,用于存储栈元素和指示栈顶位置;- 入栈,即将一个元素压入栈中,同时将指针top向上挪移一个位置;- 出栈,即将栈顶元素弹出栈,同时将指针top向下挪移一个位置;- 判断栈是否为空,即判断指针top是否指向栈底。
3.3 队列的实现我们使用C++编程语言实现了队列的基本操作,包括入队、出队和判断队列是否为空等。
具体实现过程如下:- 定义一个队列结构体,并在结构体中定义一个数组、一个指针front和一个指针rear,用于存储队列元素和指示队首和队尾位置;- 入队,即将一个元素插入队列尾部,同时将指针rear向后挪移一个位置;- 出队,即将队首元素删除,同时将指针front向后挪移一个位置;- 判断队列是否为空,即判断指针front和指针rear是否相等。
数据结构实验报告
数据结构实验报告摘要:本实验是针对数据结构概念与应用的课程要求进行的,主要目的是通过实践掌握各种数据结构的基本操作和应用场景。
在实验中,我们学习了线性表、栈、队列、二叉树等数据结构,并实现了它们的各种操作。
通过实验,我们深入理解了数据结构的原理和应用,并且掌握了如何在实际项目中应用各种数据结构来解决问题。
1. 引言数据结构是计算机科学中的一个重要概念,它研究如何组织和存储数据以及如何在这些数据上进行操作。
它对于算法的设计和优化起着至关重要的作用。
本次实验旨在通过实践,加深对数据结构的理解,并掌握其基本操作和应用场景。
2. 实验目的本实验的主要目的是:(1) 理解线性表、栈、队列和二叉树等数据结构的概念和特点;(2) 掌握各种数据结构的基本操作,如插入、删除、查找等;(3) 学会在实际项目中应用各种数据结构,解决实际问题。
3. 实验工具本实验使用的工具有:(1) 编程语言:C++;(2) 集成开发环境:Visual Studio;(3) 相关库:标准模板库(STL)。
4. 实验内容和步骤4.1 线性表线性表是最基本的数据结构之一,它包括顺序表和链表两种形式。
在本实验中,我们实现了一个基于顺序表的线性表。
具体步骤如下:(1) 定义线性表的数据结构和基本操作函数;(2) 实现线性表的初始化、插入、删除、查找、修改等基本操作;(3) 编写测试代码,验证线性表的功能和正确性。
4.2 栈栈是一种特殊的线性表,它遵循先进后出(LIFO)的原则。
在本实验中,我们实现了一个基于数组的栈。
具体步骤如下:(1) 定义栈的数据结构和基本操作函数;(2) 实现栈的初始化、入栈、出栈、查看栈顶元素等基本操作;(3) 编写测试代码,验证栈的功能和正确性。
4.3 队列队列是另一种特殊的线性表,它遵循先进先出(FIFO)的原则。
在本实验中,我们实现了一个基于链表的队列。
具体步骤如下:(1) 定义队列的数据结构和基本操作函数;(2) 实现队列的初始化、入队、出队、查看队首元素等基本操作;(3) 编写测试代码,验证队列的功能和正确性。
数据结构课程实验报告
数据结构课程实验报告目录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. 实验总结通过本次实验,学生将对数据结构与算法设计有更深入的了解,并能将所学知识应用到实际问题中,提高自己的实践能力和解决问题的能力。
树型数据结构实验
淮海工学院计算机科学系实验报告书课程名:《数据结构》题目:树型数据结构试验班级:软件082学号:110831205姓名:徐洪卫树结构算法实现与应用报告要求1目的与要求:1)熟练掌握二叉树的二叉链表表示及前序创建算法与实现;2)熟练掌握二叉树的前序、中序和后序递归遍历算法与实现;3)掌握中序遍历线索二叉树的基本算法与实现4)掌握中序遍历线索化二叉树的算法与实现;5)按照实验题目要求独立完成实验内容(提交程序清单及相关实验数据与运行结果);6)认真书写实验报告,并按时提交。
2 实验内容或题目实验内容:1)按照先序序列建立下图所示二叉树的二插链表树,结点元素类型取字符型,树的字符序列从键盘逐个动态输入。
2)在第1)步建立好的二叉链表树上实施前序、中序和后序递归遍历,并输出相应遍历序列。
3) 在第1) 步建立好的二叉链表树上实施前序遍历的叶子结点输出。
4) 在第1) 步建立好的二叉链表树上实施前序遍历的非叶子结点输出。
5)中序线索化第1)步所建立的二叉链表树(选做)。
6)中序遍历第5)步所建立的线索二叉树,并输出遍历结果(选做)ABC DE FG3 实验步骤与源程序#include <stdio.h>#include <malloc.h>#include <conio.h>typedef char DataType;typedef struct Node{DataType data;struct Node *LChild;struct Node *RChild;}BiTNode, *BiTree;void CreateBiTree(BiTree *bt){char ch;ch = getchar();if(ch=='.') *bt=NULL;else{*bt=(BiTree)malloc(sizeof(BiTNode)); //生成一个新结点 (*bt)->data=ch;CreateBiTree(&((*bt)->LChild)); //生成左子树CreateBiTree(&((*bt)->RChild)); //生成右子树}}void Visit(char ch){printf("%c ",ch);}void PreOrder(BiTree root)/*先序遍历二叉树, root为指向二叉树(或某一子树)根结点的指针*/ {if (root!=NULL){Visit(root ->data); /*访问根结点*/PreOrder(root ->LChild); /*先序遍历左子树*/PreOrder(root ->RChild); /*先序遍历右子树*/}}void InOrder(BiTree root)/*中序遍历二叉树, root为指向二叉树(或某一子树)根结点的指针*/ {if (root!=NULL){InOrder(root ->LChild); /*中序遍历左子树*/Visit(root ->data); /*访问根结点*/InOrder(root ->RChild); /*中序遍历右子树*/}}void PostOrder(BiTree root)/* 后序遍历二叉树,root为指向二叉树(或某一子树)根结点的指针*/ {if(root!=NULL){PostOrder(root ->LChild); /*后序遍历左子树*/PostOrder(root ->RChild); /*后序遍历右子树*/Visit(root ->data); /*访问根结点*/}}void PreOrderleaf(BiTree root){if(root!=NULL)if(root->LChild==NULL&&root ->RChild==NULL) printf("%c",root ->data);PreOrderleaf(root ->LChild); PreOrderleaf(root ->RChild);}}void UNPreOrderleaf(BiTree root){if(root!=NULL){if(root->LChild!=NULL||root ->RChild!=NULL) printf("%c",root ->data);UNPreOrderleaf(root ->LChild); UNPreOrderleaf(root ->RChild);}}void main(){BiTree T;int n;printf("**先序遍历序列创建二插树:**\n"); printf("请输入遍历序列('.'代表空子树):\n");CreateBiTree(&T);found: printf("请选择您要进行的操作:\n"); printf(" ****************************\n"); printf(" *1:先序遍历序列 *\n");printf(" *2:中序遍历序列 *\n"); printf(" *3:后续遍历序列 *\n"); printf(" *4:前序遍历的叶子结点输出 *\n"); printf(" *5:前序遍历的非叶子结点输出*\n"); printf(" ****************************\n"); scanf("%d",&n);switch(n){case 1:printf("先序遍历序列为:");PreOrder(T);printf("\n");printf("0.退出界面,1.返回原界面"); printf("\n");scanf("%d",&n);if(n==1)goto found;case 2:printf("\n中序遍历序列为:");InOrder(T);printf("\n");printf("0.退出界面,1.返回原界面"); printf("\n");scanf("%d",&n);if(n==1)goto found;break;case 3:printf("\n后序遍历序列为:");PostOrder(T);printf("\n");printf("0.退出界面,1.返回原界面"); printf("\n");scanf("%d",&n);if(n==1)goto found;break;case 4:PreOrderleaf(T);printf("\n");printf("0.退出界面,1.返回原界面\n");scanf("%d",&n);if(n==1)goto found;break;case 5:UNPreOrderleaf(T);printf("\n");printf("0.退出界面,1.返回原界面\n");scanf("%d",&n);if(n==1)goto found;break;}};}4 测试数据与实验结果(可以抓图粘贴)先序遍历序列创建二插树:1:先序遍历序列:2.后序遍历序列为:3.后续遍历序列:4.前序遍历的叶子结点输出:5.前序遍历的叶子结点输出:5 结果分析与实验体会这个实验,自己一共做了两次,丢了一次,得重做,挺麻烦,不过,还好,正是因为做了一次,第二次就简单多了,利用课余的时间就把它解决了。
数据结构实验报告实验1
数据结构实验报告实验1一、实验目的本次实验的主要目的是通过实际操作和编程实现,深入理解和掌握常见的数据结构,如线性表、栈、队列等,并能够运用所学知识解决实际问题。
二、实验环境本次实验使用的编程环境为Visual Studio 2019,编程语言为C++。
三、实验内容与步骤(一)线性表的实现与操作1、顺序表的实现定义一个固定大小的数组来存储线性表的元素。
实现插入、删除、查找等基本操作。
2、链表的实现定义链表节点结构体,包含数据域和指针域。
实现链表的创建、插入、删除、遍历等操作。
(二)栈的实现与应用1、栈的实现使用数组或链表实现栈的数据结构。
实现入栈、出栈、栈顶元素获取等操作。
2、栈的应用利用栈实现表达式求值。
(三)队列的实现与应用1、队列的实现使用循环数组或链表实现队列。
实现入队、出队、队头元素获取等操作。
2、队列的应用模拟银行排队系统。
四、实验结果与分析(一)线性表1、顺序表插入操作:在指定位置插入元素时,需要移动后续元素,时间复杂度为 O(n)。
删除操作:删除指定位置的元素时,同样需要移动后续元素,时间复杂度为 O(n)。
查找操作:可以直接通过索引访问元素,时间复杂度为 O(1)。
2、链表插入操作:只需修改指针,时间复杂度为 O(1)。
删除操作:同样只需修改指针,时间复杂度为 O(1)。
查找操作:需要遍历链表,时间复杂度为 O(n)。
(二)栈1、表达式求值能够正确计算简单的四则运算表达式,如 2 + 3 4。
对于复杂表达式,如(2 + 3) 4,也能得到正确结果。
(三)队列1、银行排队系统模拟了客户的到达、排队和服务过程,能够反映出队列的先进先出特性。
五、实验中遇到的问题及解决方法(一)线性表1、顺序表的空间浪费问题问题描述:当预先分配的空间过大而实际使用较少时,会造成空间浪费。
解决方法:可以采用动态分配空间的方式,根据实际插入的元素数量来调整存储空间。
2、链表的指针操作错误问题描述:在链表的插入和删除操作中,容易出现指针指向错误,导致程序崩溃。
数据结构实验报告及心得体会
数据结构实验报告及心得体会一、实验背景和目的本次实验的目的是通过设计和实现常见的数据结构,来加深对数据结构的理解,并能够熟练运用。
实验中使用的数据结构有栈、队列和链表,通过这些数据结构的设计和应用,能够更好地掌握数据结构的原理和应用。
二、实验过程1. 栈的设计和实现在本次实验中,我设计了一个基于数组的栈,用于存储数据。
首先,我定义了一个栈类,包含栈的容量、栈顶指针和存储数据的数组。
然后,我实现了入栈、出栈和判断栈空、栈满的操作。
在测试阶段,我编写了一些测试用例,验证栈的功能和正确性。
2. 队列的设计和实现在本次实验中,我设计了一个基于链表的队列。
首先,我定义了一个队列类,包含队列的头指针和尾指针。
然后,我实现了入队、出队和判断队列空、队列满的操作。
在测试阶段,我编写了一些测试用例,验证队列的功能和正确性。
3. 链表的设计和实现在本次实验中,我设计了一个能够存储任意数据类型的单链表。
首先,我定义了一个链表类,包含链表的头指针和尾指针。
然后,我实现了插入、删除和查找节点的操作。
在测试阶段,我编写了一些测试用例,验证链表的功能和正确性。
三、实验结果和分析通过本次实验,我成功设计和实现了栈、队列和链表这三种常见的数据结构。
在测试阶段,我对这些数据结构进行了充分的测试,验证了它们的功能和正确性。
在测试过程中,我发现栈和队列在实际应用中具有很大的作用。
例如,在计算表达式的过程中,可以利用栈来实现中缀表达式转后缀表达式的功能;在操作系统中,可以利用队列来实现进程的调度。
此外,在实验过程中,我还进一步加深了对数据结构的理解。
通过设计和实现数据结构,我学会了如何根据问题的需求选择合适的数据结构,并能够运用数据结构解决实际问题。
在实现过程中,我遇到了一些问题,例如链表的插入和删除操作需要考虑前后指针的变化,但通过不断的实践和思考,最终成功解决了这些问题。
同时,我还注意到数据结构的时间复杂度和空间复杂度对算法的性能有着重要的影响,因此在设计数据结构时需要充分考虑这些因素。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
淮海工学院计算机科学系实验报告书课程名:《数据结构》题目:线性数据结构试验班级:软嵌151学号:2015123352姓名:韩吉线性表实验报告要求1目的与要求:1)掌握线性表数据结构的基本概念和抽象数据类型描述;2)熟练掌握线性表数据结构的顺序和链式存储存表示;3)熟练掌握线性表顺序存储结构的基本操作算法实现;4)熟练掌握线性表的链式存储结构的基本操作算法实现;5)掌握线性表在实际问题中的应用和基本编程技巧;6)按照实验题目要求独立正确地完成实验内容(提交程序清单及相关实验数据与运行结果);7)按照报告格式和内容要求,认真书写实验报告,并于下周周二前统一提交实验报告电子版文档(每次实验全体同学必须提交实验报告电子版,实验报告文档文件命名方式:姓名+学号+数据结构第X次实验报告)提交给学委,而后由学委以班为单位统一打包(包文件名为:软件14X班-数据结构第X次实验报告)用邮件发给老师;提交纸质报告(每班每次收5份,学委安排,保证每学期每个同学至少提交一次)一起提交给老师。
每次提交电子文档时,学委务必统计和上报未交报告人数和具体姓名;凡逾期不交报告者,不再推迟提交,一律按照旷交处理。
8)积极开展实验组组内交流和辅导,严禁直接复制和剽窃他人实验成果,一旦发现严肃处理;9)上实验课前,要求每个同学基本写好程序,并存储在自己的U盘上,用于实验课堂操作时调试和运行。
2实验内容或题目(在一个主程序中实现全部题目内容)一、顺序表的基本操作实现实验要求:数据元素类型ElemType取整型int。
按照顺序存储结构实现如下算法:1)创建任意整数线性表(即线性表的元素值随机在键盘上输入)的顺序存储结构(即顺序表),长度限定在25之内;2)打印/显示(遍历)该线性表(依次打印/显示出表中元素值);3)在顺序表中查找第i个元素,并返回其值;4)在顺序表第i个元素之前插入一已知元素;5)在顺序表中删除第i个元素;6)求顺序表中所有元素值(整数)之和;二、链表(带头结点)基本操作实验要求:数据元素类型ElemType取字符型char。
按照动态单链表结构实现如下算法:1)按照头插法或尾插法创建一个带头结点的字符型单链表(链表的字符元素从键盘输入),长度限定在10之内;2)打印(遍历)该链表(依次打印出表中元素值,注意字符的输入顺序与链表的结点顺序);3)在链表中查找第i个元素,i合法返回元素值,否则,返回FALSE;4)在链表中查找与一已知字符相同的第一个结点,有则返回TRUE,否则,返回FALSE;5)在链表中第i个结点之前插入一个新结点;6)在线性表中删除第i个结点;7)计算链表的长度。
3实验步骤与源程序#include"stdio.h"#include"stdlib.h"#include"malloc.h"#define OK 1#define ERROR 0#define TURE 1#define FALSE 0#define ElemType int#define MAXSIZE 25typedef struct{ElemType elem[MAXSIZE];int last;}SeqList;int GetData(SeqList *L,int i){return L->elem[i-1];}int InsList(SeqList *L,int i,ElemType e){int k;if((i<1)||(i>L->last+2)){printf("插入位置i值不合法!");return(ERROR);}if(L->last>=MAXSIZE-1){printf("超出了链表的最大范围,无法插入无法插入!");return(ERROR);}for(k=L->last;k>=i-1;k--)L->elem[k+1]=L->elem[k];L->elem[i-1]=e;L->last++;return(OK);}int DelList(SeqList *L,int i,ElemType *e){int k;if((i<1)||(i>L->last+1)){printf("删除位置不在表中,不合法!");return(ERROR);}*e=L->elem[i-1];for(k=i;k<=L->last;k++)L->elem[k-1]=L->elem[k];L->last--;return(OK);}int SumList(SeqList *L){int sum=0;for(int i=0;i<=L->last;i++){sum+=L->elem[i];}return(sum);}void main(){SeqList *l;int p; //要查找的位置int *q;int r; //线性表的长度int t; //插入的元素int s; //删除的位置int w; //要插入的位置int i;l=(SeqList *)malloc(sizeof(SeqList));q=(int*)malloc(sizeof(int));printf("请输入线性表的长度:");scanf("%d",&r);l->last=r-1;printf("请输入线性表中的各元素值:\n");for(i=0;i<=l->last;i++){scanf("%d",&l->elem[i]);}printf("线性表中所有元素之和是:%d\n",SumList(l));printf("请输入要查找的位置: ");scanf("%d",&p);printf("查找的元素是:%d\n",GetData(l,p));printf("请输入要插入的位置:");scanf("%d",&w);printf("插入的元素是: ");scanf("%d",&t);InsList(l,p,t);printf("插入后的线性表:\n");for(i=0;i<=l->last;i++){printf("%d ",l->elem[i]);}printf("\n");printf("请输入要删除的位置:");scanf("%d",&s);DelList(l,s,q);printf("删除的元素值是:%d\n",*q);printf("删除后的线性表:\n");for(i=0;i<=l->last;i++){printf("%d ",l->elem[i]);}}// 数据结构第二题.cpp : Defines the entry point for the console application. //#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define OK 1#define ERROR 0#define TURE 1#define FALSE 0typedef char ElemType;typedef struct Node{ElemType data;struct Node*next;}Node,*LinkList;void CreateTail(LinkList L);int DelList(LinkList L,int i,ElemType e); void Get(LinkList L,int i);void InitList(LinkList *l);int InsList(LinkList L,int i,ElemType e); int ListLength(LinkList L);void Locate(LinkList L,ElemType e);void main(){LinkList k;int m; //要查找的序号int n; //要插入的位置int t; // 要删除的位置char a; //要查找的元素InitList(&k);Node *p;p=k->next;printf("用尾插法建立单链表,请输入链表数据,以$结束!\n"); CreateTail(k);while(p!=NULL){printf("%c\n",p->data);p=p->next;}printf("请输入要查找的序号: ");scanf("%d",&m);printf("查找到的元素是: ");Get(k,m);printf("\n请输入要查找的元素: ");scanf(" %c",&a);Locate(k,a);printf("\n请输入要插入的位置: ");scanf("%d",&n);printf("插入的元素是: ");scanf(" %c",&a);InsList(k,n,a);printf("插入后的链表是: ");p=k->next;while(p!=NULL){printf("%c ",p->data);p=p->next;}printf("\n请输入要删除的位置: ");scanf("%d",&t);DelList(k,t,a);printf("删除的元素是:%c\n",a);scanf("%c",&a);printf("删除后的链表是: ");p=k->next;while(p!=NULL){printf("%c ",p->data);p=p->next;}printf("\n链表的长度是:%d\n",ListLength(k)); }void InitList(LinkList *k){*k=(LinkList)malloc(sizeof(Node));(*k)->next=NULL;}void CreateTail(LinkList L){char c;Node *r,*s;int flag=1;r=L;while(flag){c=getchar();if(c!='$'){s=(Node*)malloc(sizeof(Node));s->data=c;r->next=s;r=s;}else{flag=0;r->next=NULL;}}}void Get(LinkList L,int i){int j;Node *p;p=L;j=0;while(p->next!=NULL&&j<i){p=p->next;j++;}if(i==j)printf("%c",p->data);elseprintf("FALSE");}void Locate(LinkList L,ElemType e) {Node *p;p=L->next;while(p!=NULL)if(p->data!=e)p=p->next;else break;if(p->data==e)printf("TURE");elseprintf("FALSE");}int InsList(LinkList L,int i,ElemType e) {Node *pre,*s;int k;pre=L;k=0;while(pre!=NULL&&k<i-1){pre=pre->next;k=k+1;}if(k!=i-1){printf("插入位置不合法!");return ERROR;}s=(Node*)malloc(sizeof(Node));s->data=e;s->next=pre->next;pre->next=s;return OK;}int DelList(LinkList L,int i,ElemType e){Node *p,*r;int k;p=L;k=0;while(p!=NULL&&k<i-1){p=p->next;k=k+1;}if(k!=i-1){printf("删除结点的位置不合法!");return ERROR;}r=p->next;p->next=p->next->next;e=r->data;free(r);return OK;}int ListLength(LinkList L){Node *p;p=L->next;int j=0;while(p!=NULL){p=p->next;j++;}return j;}4测试数据与实验结果(可以抓图粘贴)5结果分析与实验体会此次试验所使用的基本概念为上学期的链表的内容,而链表主要是通过结点等跳来跳去,充分利用空间,而且链表,指针通常搭配使用,这增加了理解上的难度,只要有一错错误,整个程序便会出现错误,所以此次试验尽管题目不难,但写起代码非常麻烦,尤其是c语言学得不好的,更会吃力。