数据结构实验报告册
数据结构实验报告实验5
数据结构实验报告实验5一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构,如链表、栈、队列、树和图等,并通过实际编程实现,提高对数据结构的操作和应用能力。
同时,培养解决实际问题的思维和编程能力,提高代码的可读性、可维护性和效率。
二、实验环境本次实验使用的编程语言为C++,开发环境为Visual Studio 2019。
三、实验内容1、链表的基本操作创建链表插入节点删除节点遍历链表2、栈的实现与应用用数组实现栈用链表实现栈栈的应用:括号匹配3、队列的实现与应用用数组实现队列用链表实现队列队列的应用:排队模拟4、二叉树的遍历前序遍历中序遍历后序遍历5、图的表示与遍历邻接矩阵表示法邻接表表示法深度优先遍历广度优先遍历四、实验步骤1、链表的基本操作创建链表:首先定义一个链表节点结构体,包含数据域和指向下一个节点的指针域。
然后通过动态内存分配创建链表节点,并将节点逐个连接起来,形成链表。
插入节点:根据插入位置的不同,分为在表头插入、在表尾插入和在指定位置插入。
在指定位置插入时,需要先找到插入位置的前一个节点,然后进行节点的连接操作。
删除节点:同样需要根据删除位置的不同进行处理。
删除表头节点时,直接将头指针指向下一个节点;删除表尾节点时,找到倒数第二个节点,将其指针置为空;删除指定位置节点时,找到要删除节点的前一个节点,然后调整指针。
遍历链表:通过从链表头开始,依次访问每个节点,输出节点的数据。
2、栈的实现与应用用数组实现栈:定义一个固定大小的数组作为栈的存储空间,同时用一个变量记录栈顶位置。
入栈操作时,先判断栈是否已满,如果未满则将元素放入栈顶位置,并更新栈顶位置;出栈操作时,先判断栈是否为空,如果不空则取出栈顶元素,并更新栈顶位置。
用链表实现栈:与链表的操作类似,将新元素添加在链表头部作为栈顶。
括号匹配:输入一个包含括号的字符串,使用栈来判断括号是否匹配。
遇到左括号入栈,遇到右括号时与栈顶的左括号进行匹配,如果匹配成功则出栈,否则括号不匹配。
《数据结构》实验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六、收获,体会及问题(写得越详细、越个性化、越真实越好,否则我不知道你做这个实验的心路历程,也就无法充分地判断你是否是独立完成的这个实验、你是否在做这个实验时进行了认真仔细地思考、通过这个实验你是否在实践能力上得到了提高)这次试验刚开始做时完全不知道从哪下手,才刚上了几节课,对于线性表、链式表都不是理解的很透彻,不知道用哪个软件编写程序。
数据结构实验报告
typedef OrderedLinkList polynomial;
// 用带表头结点的有序链表表示多项式
结点的数据元素类型定义为:
typedef struct polynomialnode { // 项的表示
float coef; // 系数
int expn; // 指数
while (pa&&pb) {a=pa->exn;b=pb->expn;
switch(*cmp(a,b)){ //a,b分别为pa,pb所指结点的指数
case -1:pc=pa;pa=pa->next; break; //a<b
case 0: {sum=pa->coef+pb->coef;
if (sum<>0){pa->coef=sum;pc=pa;}
else{pc->next=pa->next;free(pa);}
pa=pc->next;u=pb;pb=pb->next;free(u);
break;} //a=b
case 1: {u=pb->next;pb->next=pa;pc->next=pb;
pc=pb;pb=u; break;} //a>b
数据结构课程实验报告
学生姓名
某某
学 号
你的学号
班 级
计算机科学
指导老师
指导老师名字
实验名称
实验2 线性表
实验成绩
86
实验报告
实
验
概
述
实验目的:掌握线性表的基本操作如线性表的初始化、查找、插入、删除等,以及线性表的存概储结构的运用,并利用线性表实现一元多项式的相加。
数据结构实验报告
实验报告题目数据结构实验学生姓名学号系部专业班级指导教师二〇一〇年十二月实验1:顺序表实验一、实验目的:1.学会定义线性表的顺序存储类型,实现C程序的基本结构对线性表的一些基本操作和具体的函数定义。
2.掌握顺序表的基本操作,实现顺序表的插入,删除,查找基本运算。
3.掌握对于多函数程序的输入,编辑,调试和运算过程。
二、实验要求:1.预习C语言中结构体的定义和基本的操作方法。
2.对顺序表每个基本操作用一个单独函数实现。
3.编写完整程序完成下面实验内容并且上机运行。
三、实验内容:编写完整程序完成下面基本操作并且上机运行1.初始化顺序表La;2.将顺序表La设置为空表;3.测试顺序表La是否上空表;4.在顺序表La插入一个新元素;5.删除顺序表La中某个元素;6.在顺序表La中查找某个元素,查找成功,返回位序,否则返回0;7.建立顺序表La;8.打印顺序表La所有元素;10.输入n个元素建立顺序表La;11.归并非递减表La和Lb成为非递减表Lc。
要求编写一个主菜单调用上面各个基本操作。
四、程序体现:#include<stdio.h>#include <conio.h>#include <stdlib.h>#define LIST_INIT_SIZE 10#define LISTINCREMENT 3#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2#define Null 0typedef int status;typedef int elemtype;typedef struct {int *elem;int length;int listsize;}sqlist;status InitList(sqlist &L){L.elem=(int*)malloc(LIST_INIT_SIZE*sizeof(int));if(!L.elem)exit(OVERFLOW);L.length=10;L.listsize=LIST_INIT_SIZE;return OK;}status ClearList(sqlist &L){L.elem=Null;return OK;}status TestList(sqlist &L){if(L.elem=Null)return TRUE;elsereturn FALSE;}status ListInsert(sqlist &L,int i,int e){printf("经修改后,链表为:");int *p,*q;if(i<1||i>L.length+1)return ERROR;if(L.length>=L.listsize){int *newbase;newbase=(int *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(OVERFLOW);L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1]);for(p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p;*q=e;++L.length;return OK;}status ListDelete(sqlist &L,int i,elemtype &e){ elemtype *q, *p;if((i<1)||(i>L.length))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 OK;}int LocateElem(sqlist L,int e){int i = 0;for (i = 0; i < L.length; i++){if (L.elem[i] == e)return i + 1;}return FALSE;}void MergeList(sqlist L1,sqlist L2,sqlist &L3){printf("经合并后的新表为:");int *pa,*pb,*pc,*pa_last,*pb_last;pa=L1.elem;pb=L2.elem;L3.listsize=L3.length=L1.length+L2.length;pc=L3.elem=(int *)malloc(L3.listsize*sizeof(int));if(!L3.elem)exit(OVERFLOW);pa_last=L1.elem+L1.length-1;pb_last=L2.elem+L2.length-1;while(pa<=pa_last&&pb<=pb_last){if(*pa<=*pb)*pc++=*pa++;else *pc++=*pb++;}while(pa<=pa_last)*pc++=*pa++;while(pb<=pb_last)*pc++=*pb++;}void main(){sqlist La,Lb,Lc;int i,j,m,n,p,q,s,r;printf("创建一个新的线性表,请输入十个数字:");InitList(La);for(i=0;i<LIST_INIT_SIZE;i++)scanf("%d",&La.elem[i]);for(i=0;i<LIST_INIT_SIZE;i++)printf("%d ",La.elem[i]);printf("\n");printf("现插入一个数据,请输入它的位数和大小:");int a,b;scanf("%d%d",&a,&b);ListInsert(La,a,b);for(s=0;s<La.length;s++)printf("%d ",La.elem[s]);printf("\n");printf("现删除一个数据,请输入它的位数和大小:");int c,d;scanf("%d%d",&c,&d);ListDelete(La,c,d);for(j=0;j<La.length;j++)printf("%d ",La.elem[j]);printf("\n");printf("现查找一个数据,请输入它的位数:");int e;scanf("%d",&e);n=LocateElem(La,e);printf("n=%d",n);printf("再次创建一个新表.");InitList(Lb);for(q=0;q<LIST_INIT_SIZE;q++)scanf("%d ",&Lb.elem[q]);printf("\n");printf("现将两个线性表进行合并...");printf("\n");MergeList(La,Lb,Lc);for(r=0;r<2*LIST_INIT_SIZE;r++)printf("%d ",Lc.elem[r]);printf("\n");printf("测试线性表La是否为空,如果返回值为1,则为空:");m=TestList(La);printf("m=%d",m);printf("\n");printf("现将线性表La置为空,如果返回值为1,则置空成功.");p=ClearList(La);printf("p=%d",p);printf("\n");printf("The End!");}实验2:单链表实验一、实验目的:1.学会定义线性表的链表存储类型,实现C程序的基本结构对线性表的一些基本操作和具体的函数定义。
数据结构 实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中非常重要的一门课程,通过本次实验,旨在加深对常见数据结构(如链表、栈、队列、树、图等)的理解和应用,提高编程能力和解决实际问题的能力。
二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。
操作系统为 Windows 10。
三、实验内容1、链表的实现与操作创建一个单向链表,并实现插入、删除和遍历节点的功能。
对链表进行排序,如冒泡排序或插入排序。
2、栈和队列的应用用栈实现表达式求值,能够处理加、减、乘、除和括号。
利用队列实现银行排队系统的模拟,包括顾客的到达、服务和离开。
3、二叉树的遍历与操作构建一棵二叉树,并实现前序、中序和后序遍历。
进行二叉树的插入、删除节点操作。
4、图的表示与遍历用邻接矩阵和邻接表两种方式表示图。
实现图的深度优先遍历和广度优先遍历。
四、实验步骤及结果1、链表的实现与操作首先,定义了链表节点的结构体:```cppstruct ListNode {int data;ListNode next;ListNode(int x) : data(x), next(NULL) {}};```插入节点的函数:```cppvoid insertNode(ListNode& head, int val) {ListNode newNode = new ListNode(val);head = newNode;} else {ListNode curr = head;while (curr>next!= NULL) {curr = curr>next;}curr>next = newNode;}}```删除节点的函数:```cppvoid deleteNode(ListNode& head, int val) {if (head == NULL) {return;}ListNode temp = head;head = head>next;delete temp;return;}ListNode curr = head;while (curr>next!= NULL && curr>next>data!= val) {curr = curr>next;}if (curr>next!= NULL) {ListNode temp = curr>next;curr>next = curr>next>next;delete temp;}}```遍历链表的函数:```cppvoid traverseList(ListNode head) {ListNode curr = head;while (curr!= NULL) {std::cout << curr>data <<"";curr = curr>next;}std::cout << std::endl;}```对链表进行冒泡排序的函数:```cppvoid bubbleSortList(ListNode& head) {if (head == NULL || head>next == NULL) {return;}bool swapped;ListNode ptr1;ListNode lptr = NULL;do {swapped = false;ptr1 = head;while (ptr1->next!= lptr) {if (ptr1->data > ptr1->next>data) {int temp = ptr1->data;ptr1->data = ptr1->next>data;ptr1->next>data = temp;swapped = true;}ptr1 = ptr1->next;}lptr = ptr1;} while (swapped);}```测试结果:创建了一个包含 5、3、8、1、4 的链表,经过排序后,输出为 1 3 4 5 8 。
数据结构的实验报告
一、实验目的本次实验旨在让学生掌握数据结构的基本概念、逻辑结构、存储结构以及各种基本操作,并通过实际编程操作,加深对数据结构理论知识的理解,提高编程能力和算法设计能力。
二、实验内容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一﹑实验名称:实验一——链表二﹑实验目的: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的数据元素个数。
数据结构实验实训报告单
一、实验名称:数据结构实验实训二、实验时间:2023年10月25日三、实验地点:计算机实验室四、实验目的:1. 理解并掌握数据结构的基本概念和常用算法;2. 学会使用C++语言实现数据结构的操作;3. 提高编程能力和问题解决能力;4. 加深对数据结构在实际应用中的理解。
五、实验内容:1. 实验一:线性表(1)实验内容:实现线性表的基本操作,如插入、删除、查找、排序等。
(2)实验步骤:a. 定义线性表的数据结构;b. 实现线性表的插入、删除、查找、排序等操作;c. 编写测试程序,验证实验结果。
2. 实验二:栈与队列(1)实验内容:实现栈和队列的基本操作,并分析其时间复杂度和空间复杂度。
(2)实验步骤:a. 定义栈和队列的数据结构;b. 实现栈和队列的入栈、出栈、入队、出队等操作;c. 分析栈和队列的时间复杂度和空间复杂度;d. 编写测试程序,验证实验结果。
3. 实验三:链表(1)实验内容:实现链表的基本操作,如插入、删除、查找、排序等。
(2)实验步骤:a. 定义链表的数据结构;b. 实现链表的插入、删除、查找、排序等操作;c. 编写测试程序,验证实验结果。
4. 实验四:树与二叉树(1)实验内容:实现二叉树的基本操作,如插入、删除、查找、遍历等。
(2)实验步骤:a. 定义二叉树的数据结构;b. 实现二叉树的插入、删除、查找、遍历等操作;c. 编写测试程序,验证实验结果。
5. 实验五:图(1)实验内容:实现图的基本操作,如图的创建、添加边、查找路径等。
(2)实验步骤:a. 定义图的数据结构;b. 实现图的创建、添加边、查找路径等操作;c. 编写测试程序,验证实验结果。
六、实验心得:1. 通过本次实验,我对数据结构的基本概念和常用算法有了更深入的理解,为今后的学习和工作打下了坚实的基础。
2. 在实验过程中,我学会了使用C++语言实现数据结构的操作,提高了自己的编程能力。
3. 通过对数据结构在实际应用中的分析,我认识到数据结构在计算机科学中的重要地位,为今后的职业发展指明了方向。
数据结构实验报告_9
本科生实验报告(二)姓名:学院:专业:班级:实验课程名称: 数据结构实验日期: 2013年 5月 25 日指导教师及职称:实验成绩:开课时间:2012~2013 学年第二学期k++;a[j][n-i-1]=k;}for (j=n-i-2;j>=i;j--){k++;a[n-i-1][j]=k;}for (j=n-i-2;j>=i+1;j--){k++;[j][i]=k;}}}void main(){int n,i,j;int a[MaxLen][MaxLen];printf("输入n(n<10):");scanf("%d",&n);fun(a,n);printf("%d阶数字方阵如下:\n",n);for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",a[i][j]);printf("\n");}}运行结果:6.2:如果矩阵A中存在这样的一个元素A[i][j]满足条件:A[i][j]是第i行中值最小的元素,且又是第j列中值最大的元素,则称为该矩阵的一个马鞍点。
设计一个程序exp6-2.cpp 计算出m*n的矩阵A的所有马鞍点。
主程序如下:6.3:已知A和B为两个n*n阶的对称矩阵,输入时,对称矩阵只输入下三角形元素,存入一维数组,如图6.5所示(对称矩阵M存储在一维数组A中),设计一个程序exp6-3.cpp 实习如下功能:(1)求对称矩阵A和B的和。
(2)求对称矩阵A和B的乘积。
A:图6.5 对称矩阵的存储转换形式主程序如下:#include <stdio.h>#define N 4#define M 10int value(int a[],int i,int j){if (i>=j)return a[(i*(i-1))/2+j];elsereturn a[(j*(j-1))/2+i];}void madd(int a[],int b[],int c[][N]){int i,j;for (i=0;i<N;i++)printf("a+b:\n");disp2(c1);printf("a×b:\n");disp2(c2);printf("\n");}运行结果:6.4::假设n*n的稀疏矩阵A采用三元组表示,设计一个程序exp6-4.cpp实现如下功能:(1)生成如下两个稀疏矩阵矩阵的三元组a和b:(2)输出a转置矩阵的三元组;(3)输出a+b的三元组;(4)输出a*b的三元组。
数据结构实验报告(实验)
深 圳 大 学 实 验 报 告课程名称: 数据结构实验与课程设计 实验项目名称: 实验一:顺序表的应用 学院: 计算机与软件学院 专业: 指导教师: **报告人: 文成 学号: ********** 班级: 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。
数据结构实验报告(实验)
数据结构实验报告(实验)数据结构实验报告(实验)1. 实验目的1.1 理解数据结构的基本概念和操作1.2 学会使用数据结构解决实际问题1.3 掌握常用数据结构的实现和应用2. 实验环境2.1 操作系统:Windows 102.2 编程语言:C++2.3 开发工具:Visual Studio3. 实验内容3.1 实验一:线性表的实现和应用3.1.1 设计并实现线性表的基本操作函数3.1.2 实现线性表的插入、删除、查找等功能 3.1.3 实现线性表的排序算法3.1.4 应用线性表解决实际问题3.2 实验二:栈和队列的实现和应用3.2.1 设计并实现栈的基本操作函数3.2.2 设计并实现队列的基本操作函数3.2.3 实现栈和队列的应用场景3.2.4 比较栈和队列的优缺点3.3 实验三:树的实现和应用3.3.1 设计并实现二叉树的基本操作函数3.3.2 实现二叉树的创建、遍历和查找等功能3.3.3 实现树的遍历算法(前序、中序、后序遍历)3.3.4 应用树解决实际问题4. 数据结构实验结果4.1 实验一的结果4.1.1 线性表的基本操作函数实现情况4.1.2 线性表的插入、删除、查找功能测试结果4.1.3 线性表的排序算法测试结果4.1.4 线性表解决实际问题的应用效果4.2 实验二的结果4.2.1 栈的基本操作函数实现情况4.2.2 队列的基本操作函数实现情况4.2.3 栈和队列的应用场景测试结果4.2.4 栈和队列优缺点的比较结果4.3 实验三的结果4.3.1 二叉树的基本操作函数实现情况4.3.2 二叉树的创建、遍历和查找功能测试结果 4.3.3 树的遍历算法测试结果4.3.4 树解决实际问题的应用效果5. 实验分析与总结5.1 实验问题与解决方案5.2 实验结果分析5.3 实验总结与心得体会6. 附件附件一:实验源代码附件二:实验数据7. 法律名词及注释7.1 版权:著作权法规定的对原创作品享有的权利7.2 专利:国家授予的在一定时间内对新型发明享有独占权利的证书7.3 商标:作为标识企业商品和服务来源的标志的名称、符号、图案等7.4 许可协议:指允许他人在一定条件下使用自己的知识产权的协议。
国开数据结构(本)数据结构课程实验报告
国开数据结构(本)数据结构课程实验报告1. 实验目的本次实验的主要目的是通过实际操作,掌握数据结构的基本概念、操作和应用。
通过对实验内容的了解和实际操作,达到对数据结构相关知识的深入理解和掌握。
2. 实验工具与环境本次实验主要使用C++语言进行编程,需要搭建相应的开发环境。
实验所需的工具和环境包括:C++编译器、集成开发环境(IDE)等。
3. 实验内容本次实验主要包括以下内容:3.1. 实现顺序存储结构的线性表3.2. 实现链式存储结构的线性表3.3. 实现栈和队列的顺序存储结构和链式存储结构3.4. 实现二叉树的顺序存储结构和链式存储结构3.5. 实现图的邻接矩阵和邻接表表示4. 实验步骤实验进行的具体步骤如下:4.1. 实现顺序存储结构的线性表- 定义数据结构- 实现插入、删除、查找等操作4.2. 实现链式存储结构的线性表- 定义数据结构- 实现插入、删除、查找等操作4.3. 实现栈和队列的顺序存储结构和链式存储结构- 定义数据结构- 实现入栈、出栈、入队、出队操作4.4. 实现二叉树的顺序存储结构和链式存储结构- 定义数据结构- 实现插入、删除、查找等操作4.5. 实现图的邻接矩阵和邻接表表示- 定义数据结构- 实现插入、删除、查找等操作5. 实验结果与分析通过对以上实验内容的实现和操作,得到了以下实验结果与分析: 5.1. 顺序存储结构的线性表- 实现了线性表的插入、删除、查找等操作- 通过实验数据进行性能分析,得出了相应的性能指标5.2. 链式存储结构的线性表- 实现了线性表的插入、删除、查找等操作- 通过实验数据进行性能分析,得出了相应的性能指标5.3. 栈和队列的顺序存储结构和链式存储结构- 实现了栈和队列的入栈、出栈、入队、出队操作- 通过实验数据进行性能分析,得出了相应的性能指标5.4. 二叉树的顺序存储结构和链式存储结构- 实现了二叉树的插入、删除、查找等操作- 通过实验数据进行性能分析,得出了相应的性能指标5.5. 图的邻接矩阵和邻接表表示- 实现了图的插入、删除、查找等操作- 通过实验数据进行性能分析,得出了相应的性能指标6. 总结与展望通过本次数据结构课程的实验,我们深入了解并掌握了数据结构的基本概念、操作和应用。
数据结构实验报告册
软件学院学科基础课程实验报告册课程名称数据结构实验学期年至年第学期学生所在院(系)年级专业班级学生姓名学号指导教师实验最终成绩软件工程教研室制2010年3月实验报告须知1、学生按照“实训”课任课教师给出的题目和要求填写实验报告,填写应遵循实验报告样本格式。
2、完成的电子文档(文档、表格、演示文稿、操作过程截图等)按任课教师的要求发往指定的电子邮箱。
3、学生应该填写的内容包括:封面相关栏目、实验题目、时间、地点、实验目的、内容、过程和步骤、结果分析总结。
4、教师应该填写的内容包括:实验最终成绩、每次实验报告的成绩和对报告内容的评阅。
教师根据每学期该课程的实验教学要求,评定学生的实验成绩。
在课程结束后两周内将教学班的实验报告汇总交教学秘书存档。
5、未尽事宜,请参考该课程实验大纲和考试大纲。
实验报告(一)实验题目线性表的应用实验时间年月日实验地点实验成绩实验性质□应用性□设计性□综合性教师评阅:□实验目的明确;□操作步骤正确;□设计文稿(表格、程序、数据库、网页)符合要求;□保存路径正确;□实验结果正确;□实验分析总结全面;□实验报告规范;□其他:评阅教师签名:一、实验目的1 了解和掌握线性表的顺序存储和链式存储在计算机中的表示,基本操做在计算机中的实现。
2 能够利用线性表结构对实际问题进行分析建模,利用计算机求解。
3 能够从时间和空间复杂度的角度综合比较线性表两种存储结构的不同特点及其适用场合。
二、实验内容和要求1 利用程序设计语言分别实现顺序表和链表的抽象数据类型。
2 掌握程序分文件(头文件和实现文件)书写的方式。
3 分别用顺序表和链表实现课本算法2.2:合并两个非递减有序序列,并对其时间性能做出分析。
三、实验过程与步骤(原始记录)四、实验结果(设计文档、文稿、数据表、媒体文件存放路径)五、实验分析总结实验报告(二)实验题目栈和队列的应用实验时间年月日实验地点实验成绩实验性质□应用性□设计性□综合性教师评阅:□实验目的明确;□操作步骤正确;□设计文稿(表格、程序、数据库、网页)符合要求;□保存路径正确;□实验结果正确;□实验分析总结全面;□实验报告规范;□其他:评阅教师签名:一、实验目的1. 掌握栈和队列这两种抽象数据类型的特点,并能在相应的应用问题中正确选用它们。
数据结构实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中的重要基础课程,通过实验可以更深入地理解和掌握数据结构的概念、原理和应用。
本次实验的主要目的包括:1、熟悉常见的数据结构,如链表、栈、队列、树和图等。
2、掌握数据结构的基本操作,如创建、插入、删除、遍历等。
3、提高编程能力和解决实际问题的能力,能够运用合适的数据结构解决具体的问题。
二、实验环境本次实验使用的编程语言为C++,开发环境为Visual Studio 2019。
三、实验内容1、链表的实现与操作单向链表的创建、插入和删除节点。
双向链表的实现和基本操作。
循环链表的特点和应用。
2、栈和队列的实现栈的后进先出特性,实现入栈和出栈操作。
队列的先进先出原则,完成入队和出队功能。
3、树的操作二叉树的创建、遍历(前序、中序、后序)。
二叉搜索树的插入、查找和删除操作。
4、图的表示与遍历邻接矩阵和邻接表表示图。
深度优先搜索和广度优先搜索算法的实现。
四、实验步骤及结果1、链表的实现与操作单向链表:首先,定义了链表节点的结构体,包含数据域和指向下一个节点的指针域。
通过创建链表头节点,并使用循环依次插入新节点,实现了链表的创建。
插入节点时,根据指定位置找到插入点的前一个节点,然后修改指针完成插入操作。
删除节点时,同样找到要删除节点的前一个节点,修改指针完成删除。
实验结果:成功创建、插入和删除了单向链表的节点,并正确输出了链表的内容。
双向链表:双向链表节点结构体增加了指向前一个节点的指针。
创建、插入和删除操作需要同时维护前后两个方向的指针。
实验结果:双向链表的各项操作均正常,能够双向遍历链表。
循环链表:使链表的尾节点指向头节点,形成循环。
在操作时需要特别注意循环的边界条件。
实验结果:成功实现了循环链表的创建和遍历。
2、栈和队列的实现栈:使用数组或链表来实现栈。
入栈操作将元素添加到栈顶,出栈操作取出栈顶元素。
实验结果:能够正确进行入栈和出栈操作,验证了栈的后进先出特性。
数据结构实验报告实验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. 实现顺序表的删除操作。
4. 实现顺序表的查找操作。
5. 实现顺序表的输出操作。
三、实验步骤1. 创建顺序表的数据结构,包括数据存储数组和记录当前元素个数的变量。
2. 初始化顺序表,将当前元素个数置为0。
3. 实现顺序表的插入操作:- 判断顺序表是否已满,若已满则输出错误信息。
- 将插入位置之后的元素依次后移一位。
- 将要插入的元素放入插入位置。
- 当前元素个数加一。
4. 实现顺序表的删除操作:- 判断顺序表是否为空,若为空则输出错误信息。
- 判断要删除的位置是否合法,若不合法则输出错误信息。
- 将删除位置之后的元素依次前移一位。
- 当前元素个数减一。
5. 实现顺序表的查找操作:- 遍历顺序表,逐个比较元素值与目标值是否相等。
- 若找到目标值,则返回该元素的位置。
- 若遍历完整个顺序表仍未找到目标值,则返回错误信息。
6. 实现顺序表的输出操作:- 遍历顺序表,逐个输出元素值。
四、实验结果经过实验,顺序表的各项操作均能正确实现。
在插入操作中,可以正确将元素插入到指定位置,并将插入位置之后的元素依次后移。
在删除操作中,可以正确删除指定位置的元素,并将删除位置之后的元素依次前移。
在查找操作中,可以正确返回目标值的位置。
在输出操作中,可以正确输出顺序表中的所有元素。
五、实验总结通过本次实验,我深入了解了顺序表的原理和基本操作,并通过实际编程实现了顺序表的各项功能。
在实验过程中,我遇到了一些问题,如如何判断顺序表是否已满或为空,如何处理插入和删除位置的合法性等。
通过查阅资料和与同学讨论,我解决了这些问题,并对顺序表的操作有了更深入的理解。
数据结构实验报告
数据结构实验报告数据结构试验报告1一、试验目的及要求1)把握栈和队列这两种特别的线性表,熟识它们的特性,在实际问题背景下敏捷运用它们。
本试验训练的要点是“栈”和“队列”的观点;二、试验内容1) 利用栈,实现数制转换。
2) 利用栈,实现任一个表达式中的语法检查(选做)。
3) 编程实现队列在两种存储结构中的基本操作(队列的初始化、判队列空、入队列、出队列);三、试验流程、操作步骤或核心代码、算法片段挨次栈:Status InitStack(SqStack if(!S.base)return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE; return OK;}Status DestoryStack(SqStack return OK;}Status ClearStack(SqStack return OK;}Status StackEmpty(SqStack S) {if(S.base==S.top)return OK;return ERROR;}int StackLength(SqStack S){return S.top-S.base;}Status GetTop(SqStack S,ElemType if(!S.base) return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e; return OK;}Status Push(SqStackif(!S.base)return ERROR;S.top=S.base+S.stacksize; S.stacksize+=STACKINCREMENT; }*S.top++=e;return OK;}Status Pop(SqStacke=*--S.top;return OK;}Status StackTraverse(SqStack S){ElemType *p;p=(ElemType *)malloc(sizeof(ElemType)); if(!p) return ERROR;p=S.top;while(p!=S.base)//S.top上面一个...{p--;printf("%d ",*p);}return OK;} Status Compare(SqStackElemType e,x;InitStack(S);flag=OK;printf("请输入要进栈或出栈的元素:"); while((x= getchar)!='#'break;case ')':if(Pop(S,e)==ERROR || e!='('){printf("没有满意条件\n");flag=FALSE;}break;case ']':if ( Pop(S,e)==ERROR || e!='[')flag=FALSE;break;case '}':if ( Pop(S,e)==ERROR || e!='{') flag=FALSE;break;}}if (flag elsereturn ERROR;}链队列:Status InitQueue(LinkQueueif (!Q.front) return ERROR; Q.front->next = NULL;return OK;}Status DestoryQueue(LinkQueue free(Q.front);Q.front=Q.rear;}return OK;}Status QueueEmpty(LinkQueue return ERROR;}Status QueueLength(LinkQueue Q) {int i=0;QueuePtr p,q;p=Q.front;while(p->next){i++;p=Q.front;q=p->next; p=q;}return i;}Status GetHead(LinkQueue Q,ElemType p=Q.front->next;if(!p)return ERROR;e=p->data;return e;}Status ClearQueue(LinkQueuewhile(Q.front->next ){p=Q.front->next;free(Q.front);Q.front=p;}Q.front->next=NULL;Q.rear->next=NULL;return OK;}Status EnQueue(LinkQueuep=(QueuePtr)malloc(sizeof (QNode)); if(!p)return ERROR;p->data=e;p->next=NULL; Q.rear->next = p;Q.rear=p; //p->next 为空return OK;}Status DeQueue(LinkQueueif (Q.front == Q.rear)return ERROR;p = Q.front->next;e = p->data;Q.front->next = p->next;if (Q.rear == p)Q.rear = Q.front; //只有一个元素时(不存在指向尾指针) free (p);return OK;}Status QueueTraverse(LinkQueue Q) {QueuePtr p,q;if( QueueEmpty(Q)==OK){printf("这是一个空队列!\n"); return ERROR;}p=Q.front->next;while(p){q=p;printf("%ddata); q=p->next;p=q;}return OK;}循环队列:Status InitQueue(Sueue if(!Q.base)exit(OWERFLOW);Q.front=Q.rear=0; return OK;}Status EnQueue(Sueuereturn ERROR;Q.base[Q.rear]=e;Q.rear=(Q.rear+1)%MAXQSIZE;return OK;}Status DeQueue(Sueuee=Q.base[Q.front];Q.front=(Q.front+1)%MAXQSIZE;return OK;}int QueueLength(Sueue Q){return(Q.rear-Q.front+MAXQSIZE)%MAXQSIZE; }Status DestoryQueue(Sueuereturn OK;}Status QueueEmpty(Sueue Q) //判空{if(Q.front ==Q.rear)return OK;return ERROR;}Status QueueTraverse(Sueue Q) {if(Q.front==Q.rear)printf("这是一个空队列!");while(Q.front%MAXQSIZE!=Q.rear)} {printf("%dweight=*w;p->parent=p->rchild=p->lchild=0;}for(;iweight=p->parent=p->rchild=p->lchild=0;}for(i=n+1;i>n;w=(int*)malloc((n+1)*sizeof(int)); //记录权值,号单元未用ch=(char*)malloc((n+1)*sizeof(char));//记录字符,号单元未用cout<<"依次输入待编码的字符data及其权值weight"<for(i=1;i<=n;i++){cout<<"data["<。
数据结构实验报告
数据结构实验报告1.引言1.1 问题背景在计算机科学领域中,数据结构是研究和操作数据的一种方式。
它涉及到如何组织和存储数据,以便能够高效地检索和修改。
1.2 实验目的本实验旨在让学生深入了解一些常见的数据结构,并通过实践掌握它们的实际应用。
具体实验目的如下:________1) 熟悉线性数据结构,如数组、链表和栈。
2) 熟悉非线性数据结构,如树和图。
3) 学习并实现一些常见的数据结构算法,如排序和搜索算法。
4) 测试和分析数据结构的性能。
2.线性数据结构2.1 数组a. 定义和用途数组是一种线性数据结构,由相同类型的元素组成,并通过索引访问。
它被广泛应用于存储和访问大量数据的场景。
b. 实验要求在此实验中,我们将实现一个简单的整数数组,并提供一些基本的操作,如插入、删除和查找。
2.2 链表a. 定义和用途链表是一种线性数据结构,由一系列节点组成,每个节点包含数据和指向下一个节点的指针。
它可以灵活地分配内存,并且插入和删除操作比数组更高效。
b. 实验要求在此实验中,我们将实现一个单链表,并提供一些基本的操作,如插入、删除和查找。
2.3 栈a. 定义和用途栈是一种特殊的线性数据结构,遵循后进先出(LIFO)的原则。
它可以用于处理函数调用、表达式求值和追踪程序执行等场景。
b. 实验要求在此实验中,我们将实现一个简单的栈,并提供一些基本的操作,如压栈、出栈和查看栈顶元素。
3.非线性数据结构3.1 树a. 定义和用途树是一种非线性数据结构,由一组节点组成,通过边连接起来。
它常用于模拟分层结构和组织数据。
b. 实验要求在此实验中,我们将实现一个二叉树,并提供一些基本的操作,如插入、删除和查找。
3.2 图a. 定义和用途图是一种非线性数据结构,由一组节点和连接这些节点的边组成。
它可以用于建模网络、社交关系、路径查找等问题。
b. 实验要求在此实验中,我们将实现一个简单的图,并提供一些基本的操作,如添加节点、添加边和查找路径。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验一线性表的操作实验类型:验证性实验要求:必修实验学时: 2学时一、实验目的:参照给定的线性表顺序表类和链表类的程序样例,验证给出的线性表的常见算法。
二、实验要求:1、掌握线性表顺序表类和链表类的特点。
掌握线性表的常见算法。
2、提交实验报告,报告内容包括:目的、要求、算法描述、程序结构、主要变量说明、程序清单、调试情况、设计技巧、心得体会。
三、实验内容:1.设计一个静态数组存储结构的顺序表类,要求编程实现如下任务:建立一个线性表,首先依次输人数据元素1,2,3,…,10,然后删除数据元素6,最后依次显示当前线性表中的数据元素。
要求采用顺序表实现,假设该顺序表的数据元素个数在最坏情况下不会超过10个。
第一题源代码:#include<iostream>using namespace std;template <class T> //定义模板类SeqListclass SeqList{private:int length,x,j,data[10];public:public:SeqList( ) //无参构造函数{length=0;}SeqList(T a[ ], int n) //有参构造函数{for(int i=0;i<n;i++)data[i]=a[i];length=n;}~SeqList( ) //析构函数为空{}int Length( ) //求线性表的长度{return length;}T Get(int i) //按位查找,取线性表的第i个元素{}int Locate(T x ) //按值查找,求线性表中值为x的元素序号{}void Insert(int i, T x) //在线性表中第i个位置插入值为x的元素{}T Delete(int i) //删除线性表的第i个元素{if(length==0)throw"下溢";if(i<1||i>length)throw"位置异常";x=data[i-1];for(j=i;j<length;j++)data[j-1]=data[j]; //注意此处j已经是元素所在的数组下标length--;return x;}void PrintList( ) //遍历线性表,按序号依次输出各元素{for(int i=0;i<length;i++)cout<<data[i]<<" ";cout<<endl;}};void main(){int n=10,a[10]={1,2,3,4,5,6,7,8,9,10};SeqList<int> theseqlist(a,n);cout<<"删除前元素:";for(int i=0;i<n;i++)cout<<a[i]<<" ";cout<<endl;theseqlist.Delete(6);theseqlist.PrintList();}运行结果:---------------------------------------------------------------------------------------------------------------------- 2.设计一个带头结点的单链表类,要求:(1)带头结点单链表类的成员函数包括取数据元素个数、插入元素、删除所有值为k的元素、取数据元素。
(2)设计一个测试主函数,实际运行验证所设计循环单链表类的正确性。
第二题源代码:#include<iostream>using namespace std;template<class T>struct Node{T data;Node<T> *next;};/*****************************/template <class T>class LinkList{private:Node<T> *first; //单链表头指针int length;public:LinkList(){first=new Node<T>;first->next=NULL;}LinkList(T a[],int n) //建立n个节点的指针{Node<T> *s;first=new Node<T>;first->next=NULL; //初始化一个空链表for(int i=0;i<n;i++){s=new Node<T>;s->data=a[i];s->next=first->next;first->next=s;}length=n;}~LinkList(){Node<T> *p=first;while(p){Node<T> *q;q=p;p=p->next;delete q;}}int Length(); //求单链表长度T Get(int i); //取单链表第i个节点元素值int Locate(T x); //求单链表值为x的元素序号void Insert(int i,T x); //在单链表中第i个位置插入元素值x的节点T Delete(int i); //在单链表中删除第i个节点void PrintList(); // 遍历单链表,按序号依次输出个元素};/********************************/template<class T>int LinkList<T>::Length(){return length;}/******************************/template <class T>T LinkList<T>::Get(int i){int j;Node<T> *p;p=first->next;j=1;while(p&& j<i){p=p->next;j++;}if(!p)throw "位置";elsereturn p->data;}/***********************************/ template<class T>int LinkList<T>::Locate(T x){Node<T> *p;p=first;for(int i=0;i<length;i++){p=p->next;if(p->data==x)return i+1;}}/***********************************/ template<class T>void LinkList<T>::Insert(int i,T x){Node<T> *p;int j;p=first;j=0;while(p&&j<i-1){p=p->next;j++;}if(!p)throw"位置";else{Node<T> *s;s=new Node<T>;s->data=x;s->next=p->next;p->next=s;}length++;}/**************************************/template<class T>T LinkList<T>::Delete(int i){Node<T> *p;int j;p=first;j=0;while(p&&j<i-1){p=p->next;j++;}if(!p||!p->next)throw"位置";else{Node<T> *q;q=new Node<T>;int x;q=p->next;x=q->data;p->next=q->next;delete q;length--;return x;}}/*******************************************/template<class T>void LinkList<T>::PrintList() // 遍历单链表,按序号依次输出个元素{Node<T> *p;p=first;for(int i=0;i<length;i++){p=p->next;cout<<"第"<<(i+1)<<"个元素为:"<<(p->data)<<endl;}}/*******************************************/{int r[ ]={10,9,8,7,6,5,4,3,2,1};LinkList <int> a( r , 10 );cout<<"原表为:"<<endl;a.PrintList();cout<<endl;a.Insert(1,-2); //执行插入操作;a.Insert(2,-1);a.Insert(3,0 );cout<<"执行插入后输出为:"<<endl;a.PrintList();cout<<endl;a.Delete(1);a.Delete(1);a.Delete(1);cout<<"执行删除后输出为:"<<endl;a.PrintList();cout<<endl;cout<<"按位查找元素:"<<endl;cout<<"第5 个元素为: ";cout<<a.Get(5)<<endl; //查找链表中第5 个元素cout<<endl;}运行结果:实验二栈、队列、串的操作实验类型:验证性实验要求:必修实验学时: 2学时一、实验目的:参照给定的栈类和队列类的程序样例,验证给出的栈和队列的常见算法,并结合线性表类实现有关串的操作。