数据结构上机实验报告
上机实验报告(精选11篇)
上机实验报告篇1用户名se××××学号姓名学院①实验名称：②实验目的：③算法描述（可用文字描述，也可用流程图）：④源代码：（.c的文件）⑤用户屏幕（即程序运行时出现在机器上的画面）：2．对c文件的要求：程序应具有以下特点：a可读性：有注释。
b交互性：有输入提示。
c结构化程序设计风格：分层缩进、隔行书写。
3.上交时间：12月26日下午1点-6点，工程设计中心三楼教学组。
请注意：过时不候哟！四、实验报告内容0．顺序表的插入。
1.顺序表的删除。
2．带头结点的单链表的\'插入。
3.带头结点的单链表的删除。
注意：1.每个人只需在实验报告中完成上述4个项目中的一个，具体安排为：将自己的序号对4求余，得到的数即为应完成的项目的序号。
例如：序号为85的同学，85%4=1，即在实验报告中应完成顺序表的删除。
2.实验报告中的源代码应是通过编译链接即可运行的。
3.提交到个人空间中的内容应是上机实验中的全部内容。
上机实验报告篇2一、《软件技术基础》上机实验内容1．顺序表的建立、插入、删除。
2．带头结点的单链表的建立（用尾插法）、插入、删除。
二、提交到个人10m硬盘空间的内容及截止时间1．分别建立二个文件夹，取名为顺序表和单链表。
2．在这二个文件夹中，分别存放上述二个实验的相关文件。
每个文件夹中应有三个文件(.c文件、.obj文件和.exe文件)。
3. 截止时间：12月28日（18周周日）晚上关机时为止，届时服务器将关闭。
三、实验报告要求及上交时间（用a4纸打印）1．格式：《计算机软件技术基础》上机实验报告用户名se××××学号姓名学院①实验名称：②实验目的：③算法描述（可用文字描述，也可用流程图）：④源代码：（.c的文件）⑤用户屏幕（即程序运行时出现在机器上的画面）：2．对c文件的要求：程序应具有以下特点：a 可读性：有注释。
b 交互性：有输入提示。
数据结构上机实验报告
else insert(lc,i/2,la.list[i]); //偶数位次元素插入lc
}
printf("\n您输入的线性表元素为:\n\n");
print(la);
printf("线性表的奇数位次的元素为：\n\n");
print(lb);
printf("线性表的偶数位次的元素为：\n\n");
print(lc);
}
void initial(sqlist &v)
{printf(" ****本程序可以实现线性表奇偶位序的元素分别输出****\n\n\n");
int i,a;
printf("请输入一个偶数作为线性表的长度：\n\n");
void initlist(sqlist &);
void print(sqlist); //输出线性表
void main()
{printf(" *****************本程序可以实现线性表的复制******************\n");
sqlist la,lb; //声明线性表
initial(la);
【程序设计细想】：
建立三个线性表la,lb,lc，对线性表la进行输入，然后利用循环结构对la中奇数位序的元素对lb进行插入操作，对偶数位序的元素对lc进行插入操作，从而得到线性表lb和lc。
【程序代码】：
#include<stdio.h>
#include<malloc.h>
数据结构实验报告-实验：1线性表的顺序存储和操作实现
}
for(inti=pos-1;i<length;i++)
if(listArray[i].equals(obj))returni+1;
return-1;
}
publicbooleanmodify(Object obj,intpos){
if(pos<1||pos>length){
List sort();
}
publicclasssequenceListimplementsList {
finalintmaxSize=10;
privateintlength;
privateObject[]listArray;
publicsequenceList(){//无参数的构造函数的定义
length=0;//线性表初始为空，即长度为0
System.out.println();
list2.preOrder();
System.out.println("线性表list2长度："+list2.size());
}
}
publicinterfaceList {
Object value(intpos);
booபைடு நூலகம்eanadd(Object obj,intpos);
int[] a={20,16,38,42,29};
for(inti=0;i<a.length;i++) list1.add(a[i], i+1);
intn1=(Integer)list1.remove(2);
list1.add(80, 3);
intn2=(Integer)list1.value(4);
数据结构上机报告
课程实验报告课程名称：数据结构专业班级：学号：姓名：指导教师：报告日期：计算机科学与技术学院目录1 课程实验概述 (1)2 实验一基于顺序结构的线性表实现2.1 问题描述 (2)2.2 系统设计 (2)2.3 系统实现 (3)2.4 效率分析 (12)3 实验二基于链式结构的线性表实现3.1 问题描述 (14)3.2 系统设计 (14)3.3 系统实现 (15)3.4 效率分析 (26)4 实验三基于二叉链表的二叉树实现4.1 问题描述 (27)4.2 系统设计 (27)4.3 系统实现 (29)4.4 效率分析 (45)5 实验总结与评价 (47)附录附录1 顺序线性表 (48)附录2 链式线性表 (61)附录3 二叉树 (75)1 课程实验概述线性表是最常用且最简单的一种数据结构。
简言之，一个线性表是n个数据元素的有限序列。
至于每个数据元素的具体含义，在不同的情况下各不相同。
线性表的长度可根据需要增长或缩短，即对线性表的数据元素不仅可以进行访问，还可进行插入和删除等操作。
树型结构是一类重要的非线性数据结构。
其中以树和二叉树最为重要，直观看来，树是以分支关系定义的层次结构。
本实验将通过C语言来实现线性表顺序储存结构、线性表链式储存结构以及二叉树链表的基本的、常见的运算。
2 实验一基于顺序结构的线性表实现2.1 问题描述基于顺序储存结构，实现线性表的构造、销毁、置空、插入、删除等运算。
2.2 系统设计（1）IntiaList(SqList * L)操作结果：构造一个空的线性表L（2）DestroyList(SqList * L)初始条件：线性表L己存在操作结果：销毁线性表L（3）ClearList(SqList *L)初始条件：线性表L己存在操作结果：将L重置为空表（4）ListEmpty(SqList L)初始条件：线性表已存在操作结果：若L为空表，则返回TRUE,否则返回FALSE（5）ListLength(SqList L)初始条件：线性表L已经存在操作结果：返回L中数据元素个数（6）GetElem(SqList L,int i,Elemtype * e)初始条件：线性表L己经存在，1<=i<=Listlength(L)操作结果：用e返回L中第（i-1）个元素的值（7）LocatElem(SqList L,Elemtype e,status (* compare)(Elemtype ,Elemtype ))初始条件：线性表L已存在,compare()是元素判定函数操作结果：返回L中第1个与e满足关系的数据元素的次序。
数据结构上机报告
数据结构上机报告班级：通信工程1405 姓名：李笑阳学号：U201413536一．约瑟夫环1.需求分析①．约瑟夫问题的一种描述是：编号为1，2，……，n点的n个人按顺时针方向围坐一个圈，每人持有一个密码。
一开始选一个正整数作为报数上限值m，从第一个人开始从顺时针方向自1开始报数，报到m时停止。
报到m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个人开始从新从1报数，如此下去，直达所有人出列。
②．基本要求：利用单向循环链表存储结构模拟此过程，按照出列的顺序输出各人的编号。
③．演示程序提示用户输入其总人数，然后依此输入每个人的数字，程序按照出列的顺序输出各人的编号。
测试数据：m的初始值为20；n=7，7个人的密码依次是3，1，7，2，4，8，4，首先m 的值为6（正确的出列顺序为6，1，4，7，2，3，5）2.设计概要①循环链表的结点类型定义typedef struct LNode②．创建链表模块LinkList creatList_L(int n)③．删除链表并释放空间模块void ListDelete_L(LinkList L,int key,int n)④．主函数模块（约瑟夫环的实现）Void main()3.具体代码实现#include<stdio.h>#include<malloc.h>//定义结构体typedef struct LNode{int password,num;struct LNode *next;}LNode,*LinkList;//创建链表LinkList creatList_L(int n){LinkList p,head,q;int i=1,key;head=(LinkList)malloc(sizeof(LNode));p=head;for(i=1;i<=n;i++) //进入循环赋值{scanf("%d",&key);q=p;p=(LinkList)malloc(sizeof(LNode));p->num=i;p->password=key;q->next=p;}p->next=head->next;free(head); ////现在的p节点是列表的尾节点把尾节点的下一个指向头结点//也就是形成了一个环head=p->next;return (head);}//输出并删除列表void ListDelete_L(LinkList L,int key,int n){LinkList p,s;int j=1;while(n>0){p=L;//key是人数上限M==key 现在开始循环叫数叫到M的输出//并从循环链表中删除for(j=1;j<key;j++){s=p;p=p->next;}printf("%2d %5d\n",p->num,p->password);key=p->password;//s是p的上一个节点，现在把s的下一个节点指向p的下一个s->next=p->next;L=p->next;//释放p节点free(p);//链表总数减一，一直到n==0时退出while循环n--;}}void main(){LinkList s;int n,m;printf("请输入总人数N和上限数M:");scanf("%d%d",&n,&m);printf("请输入%d个人的密码:",n);s=creatList_L(n); //调用创建列表printf("序号密码\n");ListDelete_L(s,m,n); //调用输出并删除列表}4.运行分析①．运行结果②．复杂度的分析时间复杂度为O(n2），空间复杂度为O（n）5．实验总结这个算法中的主函数只完成输入输出，其他都是通过调用完成。
数据结构上机实验二(更新)
数据结构上机实验二实验内容:栈和链队列的基本操作实验目的:1)熟悉C/C++基本编程,培养动手能力.2)通过实验,加深对堆栈和队列的理解.实验要求:1) 栈和队列的显示要作为函数被调用.2) 把自己使用的栈和队列结构明确的表达出来.分组要求：可单独完成，也可两人一组。
评分标准：1) 只完成第一或第二题，3分；2）完成一和二题，得5分；3）在2）基础上，可选做三）中的题目。
题目:一)堆栈题（顺序栈）:创建一个栈+入栈+出栈(1)由键盘一个一个的输入正整数，建立相应的堆栈，输入-1时，堆栈结束；(2)在（1）中创建的堆栈中添加一个元素；(3)在（1）中创建的堆栈中删除一个元素；(要求在显示器可见)；#include<stdio.h>#include<stdlib.h>#include <string>#define OK 1#define ERROR 0#define Status int#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef struct Stack{int *base;int *top;Status stacksize;}SqStack;Status CreatStack(SqStack &S) //创建空栈{S.base=(int*)malloc(STACK_INIT_SIZE*sizeof(struct Stack));if(!S.base) return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status InStack(SqStack &S) //创建栈元素int e;printf("请输入初始栈元素:\n");scanf("%d",&e);while(e!=-1){if(S.top-S.base>=S.stacksize) //栈满,追加存储空间{S.base=(int*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(struct Stack));if(!S.base) return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;scanf("%d",&e);}return OK;}Status Push(SqStack &S,int e) //栈加元素{if(S.top-S.base>=S.stacksize) //栈满,追加存储空间{S.base=(int*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(struct Stack));if(!S.base) return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S,int e) //栈中删除元素{if(S.top==S.base) return ERROR;e=*--S.top;printf("\n请输出出栈元素:%d",e);return OK;}void print(){printf("\n菜单：");printf("\n1.创建栈：");printf("\n2.入栈：");printf("\n3.出栈：");printf("\n4.退出：");}void printS(SqStack &S) //打印堆栈{int *p;printf("请输出堆栈中的元素:\n");for(p=S.base;p<S.top;p++){printf("%d ",*p);}}void main() //主程序{SqStack S;int e,choice;do{print();printf("\n请输入你的选项：");scanf("%d",&choice);switch(choice){case 1:if(CreatStack(S)==1){if(InStack(S)==1)printS(S);}break;case 2:printf("\n请输入入栈元素：");scanf("%d",&e);Push(S,e);printS(S);break;case 3:Pop(S,e);printS(S);break;case 4:break;}}while(1);}}二)链队列题目：初始化队列+入队列+出队列+销毁队列(1)初始化一个链队列；(2)在初始化好的链队列中放入数，入队列，完成后要求显示；(3)从队列中出队列，要求显示出来的元素和之后的队列；(4)销毁创建的队列，释放内存；#include<stdio.h>#include<stdlib.h>#define OK 1#define ERROR 0#define Status inttypedef struct Qnode{int data;struct Qnode *next;}QNode, *QueuePtr;typedef struct {QueuePtr front; //队头指针QueuePtr rear; //队尾指针}LinkQueue;Status CreatQueue(LinkQueue &Q) //初始化队列{Q.front=Q.rear=(QueuePtr) malloc(sizeof(QNode)); if(!Q.front) return ERROR;Q.front->next=NULL;return OK;}Status InQueue(LinkQueue &Q) //输入队列元素{QueuePtr p; int e;p=(QueuePtr)malloc(sizeof(QNode));if(!p) return ERROR;printf("请输入初始队列元素：\n");scanf("%d",&e);while(e!=-1){p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;p=(QueuePtr)malloc(sizeof(QNode));if(!p) return ERROR;scanf("%d",&e);}return OK;}Status EnQueue(LinkQueue &Q,int e) //入队列{QueuePtr p;p=(QueuePtr)malloc(sizeof(QNode));if(!p) return ERROR;p->data=e; p->next=NULL;Q.rear->next=p;Q.rear=p;return OK;}Status DeQueue(LinkQueue &Q,int &e) //出队列{QueuePtr p;if(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 DestroyQueue (LinkQueue &Q) // 销毁队列{while(Q.front){Q.rear=Q.front->next;free(Q.front);Q.front=Q.rear;}return OK;}void print() //打印菜单{printf("\n菜单：");printf("\n1.创建队列：");printf("\n2.入队列：");printf("\n3.出队列：");printf("\n4.销毁队列：");}void printS(LinkQueue &Q) //打印队列{QueuePtr p;p=Q.front->next;printf("请输出队列中的元素:\n");while(p){printf("%d ",p->data);p=p->next;}}void main(){LinkQueue Q;int e,choice;do{print();printf("\n请输入你的选项：");scanf("%d",&choice);switch(choice){case 1:if(CreatQueue(Q)==1){if(InQueue(Q)==1)printS(Q);}break;case 2:printf("请输入入队列元素：");scanf("%d",&e);EnQueue(Q,e);printS(Q);break;case 3:DeQueue(Q,e);printS(Q);break;case 4:DestroyQueue(Q);if(Q.front=NULL)printS(Q);else printf("队列不存在");break;}}while(1);}三）应用题（1）编制程序，将输入的十进制数据M 转换为八进制数据M8，将其调试通过。
数据结构上机实验报告
数据结构上机实验报告数据结构上机实验报告1. 实验目的数据结构是计算机科学中非常重要的一门课程，通过本次上机实验，旨在帮助学生巩固和应用所学的数据结构知识，培养学生分析和解决实际问题的能力。
2. 实验背景本次实验涉及到两个常用的数据结构：栈和队列。
栈是一种后进先出（Last In First Out，LIFO）的数据结构，而队列是一种先进先出（First In First Out，FIFO）的数据结构。
通过实验，我们将学习如何使用这两种数据结构来解决实际问题。
3. 实验内容本次实验分为两个部分：栈的应用和队列的应用。
3.1 栈的应用在栈的应用部分，我们将实现一个简单的括号匹配算法。
该算法可以判断一个字符串中的括号是否匹配。
具体实现步骤如下：3.1.1 创建一个栈来存储括号字符；3.1.2 遍历字符串中的每个字符；3.1.3 如果遇到左括号，则将其入栈；3.1.4 如果遇到右括号，则判断栈顶元素是否是对应的左括号；3.1.5 如果栈为空或栈顶元素不是对应的左括号，则括号不匹配；3.1.6 如果栈顶元素是对应的左括号，则将其出栈；3.1.7 遍历完字符串后，如果栈为空，则括号匹配，否则括号不匹配。
通过实现这个算法，我们可以学习到如何使用栈来解决实际问题，并且理解栈的后进先出的特性。
3.2 队列的应用在队列的应用部分，我们将实现一个简单的任务调度算法。
该算法可以模拟多个任务按照一定的优先级进行调度的过程。
具体实现步骤如下：3.2.1 创建一个队列来存储任务；3.2.2 每个任务包含两个属性：任务名称和优先级；3.2.3 向队列中添加任务，并按照优先级进行排序；3.2.4 从队列中取出优先级最高的任务，并执行；3.2.5 执行完任务后，继续从队列中取出下一个优先级最高的任务，并执行，直到队列为空。
通过实现这个算法，我们可以学习到如何使用队列来实现任务调度，并且理解队列的先进先出的特性。
4. 实验结果与分析通过实验，我们成功实现了括号匹配算法和任务调度算法，并得到了正确的结果。
数据结构上机报告1
实验1（线性表）：任意输入一串字符，将该字符串看成一个线性表，以链式存储结构(或者静态链表)实现这个线性表，并进行线性表的查找、插入、删除和就地逆置等操作1.需求分析意输入一串字符，将该字符串看成一个线性表，以链式存储结构(或者静态链表)实现这个线性表，并进行线性表的查找、插入、删除和就地逆置等操作2.详细设计1.主函数{输入字符串；生成线性表；调用函数，实现操作；}2.调用函数{ 查找函数；插入函数；删除函数；逆置函数；}3.调用关系图为：void main(){ list_search(); list_insert;list_delete; list_turn()}ADT List{数据对象：D={a i|a i=ElemSet,i=1,2,……,n,n≧0}数据关系：R1={<a i-1,a i>| a i-1,a i€D, i=1,2,……,n }基本操作：list_search (&l); //查找函数list_insert (&l); //插入函数list_delete (&l) ; //删除函数list_turn (&l) //就地逆置}3.用户使用说明先输入一个字符串，回车键结束，程序会自动生成一个线性链表；接着会出现操作选择界面，输入所要进行的操作：输入1进行查找操作，输入要查找元素就会输出元素位置；程序如下：#include<stdio.h>#include<stdlib.h>#include<string.h>struct node{ char data;struct node* prior;struct node* next;};void list_search(struct node* head);void list_insert(struct node* head,int lenth);void list_delete(struct node* head,int lenth);void list_turn(struct node *head);//主函数void main(){struct node head;head.data=0;head.next=NULL;head.prior=NULL;struct node* p=&head;struct node* q=&head;int i=0;char c;printf("请输入字符串:\t");scanf("%c",&c);while(c!='\n'){i++;q=(struct node*)malloc(sizeof(struct node));q->prior=p;q->next=NULL;q->data=c;p->next=q;p=q;scanf("%c",&c);}fflush(stdin);int number=i;p=&head;printf("生成的线性表为:\n");while(p->next){p=p->next;printf("%c",p->data);}int flag=1;char choose;char judge[4];while(flag){printf("\n");printf("请输入你想进行的操作:\n");printf("1---查找\t");printf("2---插入\t");printf("3---删除\t");printf("4---就地逆置\n");int flag1=1;while(flag1){scanf("%c",&choose);fflush(stdin);if(choose=='1'){list_search(&head);flag1=0;} if(choose=='2'){list_insert(&head,number);flag1=0;p=&head;printf("线性表现在变为:\n");while(p->next){p=p->next;printf("%c",p->data);}}if(choose=='3'){list_delete(&head,number);flag1=0;p=&head;printf("线性表现在变为:\n");while(p->next){p=p->next;printf("%c",p->data);}}if(choose=='4'){list_turn(&head);flag1=0;p=&head;printf("线性表现在变为:\n");while(p->next){p=p->next;printf("%c",p->data);}}}int i=number;fflush(stdin);printf("\n继续请输入yes,退出请输入no\n");gets(judge);if(strcmp(judge,"yes")) flag=0;if(strcmp(judge,"no"));}//whileprintf("谢谢使用~\n");}//main//查找函数void list_search(struct node* head){char temp;printf("请输入你要查找的元素:\n");fflush(stdin);scanf("%c",&temp);struct node* p=head;struct node* q=head;int i=0;int flag=1;while(p->next){p=p->next;i++;if(p->data==temp){printf("所查元素的位置是:\t");printf("%d\n",i);flag=0;printf("\n");}}if(flag) printf("所查元素不在线性表内!\n"); }//list_search//插入函数void list_insert(struct node* head,int number){char temp;int pos;printf("请输入你要插入的元素:\n");fflush(stdin);scanf("%c",&temp);int flag=1;while(flag){printf("请输入所插入元素的位置\n");fflush(stdin);scanf("%d",&pos);if(pos>=number||pos<=0) {printf("输入错误,请重新输入!\n");continue;} else flag=0;}struct node* p=head;struct node* q=head;int i=0;while(i<pos-1){p=p->next;i++;}q=(struct node*)malloc(sizeof(struct node));q->data=temp;p->next->prior=q;q->next=p->next;q->prior=p;p->next=q;}//list_insert//删除函数void list_delete(struct node* head,int number){int temp;int flag=1;while(flag){printf("请输入所要删除元素的位置:\n");fflush(stdin);scanf("%d",&temp);if(temp>=number||temp<=0) {printf("输入错误,请重新输入!\n");continue;} else flag=0;}struct node* p=head;struct node* q=head;while(temp){p=p->next;temp--;}q=p->prior;q->next=p->next;if(p->next)p->next->prior=q;free(p);}//list_delete//逆置函数void list_turn(struct node *head) {struct node* p=head;struct node* q=head;struct node* r=q->next;while(r){p=r;r=r->next;q=p->prior;p->prior=p->next;p->next=q;}p->prior=head;head->next->next=NULL;head->next=p;p=head;}//list_inverse set调试结果：。
数据结构上机实验报告
数据结构实验报告课程数据结构 _ 院系专业班级实验地点姓名学号实验时间指导老师数据结构上机实验报告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学号__________ 姓名___刘旺________班级____软件1312_________一上机目的a、熟练掌握线性表定义b、熟练掌握线性表逻辑结构c、熟练掌握线性表的两种存储结构d、熟练掌握相关的基本运算及应用二上机内容1）、实现顺序存储结构下线性表的基本操作，数据类型自己确定。
2）、输入一组数据，建立带头结点的单链表，实现线性表的基本操作，线性表中数据元素的类型自己确定。
3）试写一算法，实现顺序表的就地逆置，即利用原表的存储空间将线性表（a1,a2…,an）逆置为（an,an-1…,a1）。
4）、已知有序表中的元素以值递增有序排列，并以单链表作存储结构。
试写一高效的算法，删除表中所有值大于mink且小于maxk 的元素（若表中存在这样的元素）同时释放被删结点空间，并分析你所写的算法的时间复杂度（注意mink和maxk是给定的两个参变量，它们的值可以和表中的元素相同，也可以不同）。
5）、某百货公司仓库中有一批电视机，试按价格从高到底的次序建立一个循环链表，每个结点有价格)数量和链指针三个域。
现新到m台价格为h的电视机，修改原链表并输出修改后链表的所有内容。
6*）、在理解一元多项式的加法算法基础上，编程实现一元多项式的减法。
三设计说明：写出本上机中所有用到的数据结构的定义及接口描述四功能说明：说明本程序中的每一个函数及其功能。
五调试分析：内容包括：（1）调试过程中遇到的问题是如何解决的以及对设计与实现的回顾讨论和分析（2）算法的时空分析和改进设想（3）经验与体会等六测试结果包括输入和输出(粘贴输入输出界面，即用户屏幕)七带注释的源程序上机报告2学号__________ 姓名___________班级_____________ 一上机目的a、栈和队列的顺序存储结构和链接存储结构b、掌握栈和队列的入栈与出栈，入队与出队等基本运算的实现c 、将栈和队列应用到实际问题中。
二上机内容1)、顺序栈和链栈基础上的基本操作及实现。
数据结构上机实验报告
数据结构上机实验报告一、实验目的本次数据结构上机实验的主要目的是通过实际编程操作，深入理解和掌握常见的数据结构及其基本操作，提高解决实际问题的能力和编程技能。
具体目标包括：1、熟练掌握线性表、栈、队列、树、图等数据结构的基本概念和存储方式。
2、学会运用数据结构的相关算法进行数据的插入、删除、查找、排序等操作。
3、培养分析问题、设计算法、编写代码和调试程序的综合能力。
4、增强对数据结构在实际应用中的认识，提高解决复杂问题的思维能力。
二、实验环境1、操作系统：Windows 102、编程环境：Visual Studio 20193、编程语言：C+＋三、实验内容本次实验共包括以下几个部分：1、线性表的操作实现顺序表和链表的创建、插入、删除、查找和遍历操作。
比较顺序表和链表在不同操作下的性能差异。
2、栈和队列的应用利用栈实现表达式求值。
用队列模拟银行排队系统。
3、树的遍历实现二叉树的先序、中序和后序遍历算法，并输出遍历结果。
构建哈夫曼树，并进行编码和解码操作。
4、图的基本操作用邻接矩阵和邻接表存储图，并实现图的深度优先搜索和广度优先搜索算法。
四、实验步骤及结果1、线性表的操作顺序表的实现：｀｀｀cppinclude ＜iostream>using namespace std;define MAXSIZE 100 ／／顺序表的最大长度class SeqList ｛private:int dataMAXSIZE; ／／存储顺序表元素的数组int length; ／／顺序表的当前长度public:SeqList(）｛／／构造函数，初始化顺序表length ＝ 0;｝／／插入元素bool insert(int pos, int element) ｛if （pos ＜ 0 ｜｜ pos ＞ length ｜｜ length ＝＝ MAXSIZE) ｛return false;｝for （int i ＝ length; i ＞ pos; i) ｛datai ＝ datai 1;｝datapos ＝ element;length+＋；return true;｝／／删除元素bool remove(int pos) ｛if （pos ＜ 0 ｜｜ pos ＞＝ length) ｛return false;｝for （int i ＝ pos; i ＜ length 1; i+＋）｛datai ＝ datai ＋ 1;｝length;return true;｝／／查找元素int search(int element) ｛for （int i ＝ 0; i ＜ length; i+＋）｛if （datai ＝＝ element) ｛return i;｝｝return －1;｝／／遍历输出顺序表void traverse(）｛for （int i ＝ 0; i ＜ length; i+＋）｛cout ＜＜ datai ＜＜＂＂；｝cout ＜＜ endl;｝｝；int main(）｛SeqList list;listinsert(0, 10)；listinsert(1, 20)；listinsert(2, 30)；listtraverse(）；listremove(1)；listtraverse(）；int position ＝ listsearch(30)；if （position!＝－1) ｛cout ＜＜＂元素 30 在位置＂＜＜ position ＜＜ endl;｝ else ｛cout ＜＜＂未找到元素 30" ＜＜ endl;｝return 0;｝｀｀｀链表的实现：｀｀｀cppinclude ＜iostream>using namespace std;class Node ｛public:int data;Node next;Node(int element) ｛data ＝ element;next ＝ NULL;｝｝；class LinkedList ｛private:Node head;public:LinkedList(）｛head ＝ NULL;｝／／插入元素void insert(int element) ｛Node newNode ＝ new Node(element)；if （head ＝＝ NULL) ｛head ＝ newNode;｝ else ｛Node current ＝ head;while （current>next!＝ NULL) ｛current ＝ current>next;｝current>next ＝ newNode;｝｝／／删除元素void remove(int element) ｛if （head ＝＝ NULL) ｛return;｝if （head>data ＝＝ element) ｛Node temp ＝ head;head ＝ head>next;delete temp;return;｝Node current ＝ head;Node prev ＝ NULL;while （current!＝ NULL ＆＆ current>data!＝ element) ｛prev ＝ current;current ＝ current>next;｝if （current!＝ NULL) ｛prev>next ＝ current>next;delete current;｝｝／／查找元素bool search(int element) ｛Node current ＝ head;while （current!＝ NULL) ｛if （current>data ＝＝ element) ｛return true;｝current ＝ current>next;｝return false;｝／／遍历输出链表void traverse(）｛Node current ＝ head;while （current!＝ NULL) ｛cout ＜＜ current>data ＜＜＂＂；current ＝ current>next;｝cout ＜＜ endl;｝｝；int main(）｛LinkedList list;listinsert(10)；listinsert(20)；listinsert(30)；listtraverse(）；listremove(20)；listtraverse(）；if （listsearch(30)）｛cout ＜＜＂找到元素 30" ＜＜ endl;｝ else ｛cout ＜＜＂未找到元素 30" ＜＜ endl;｝return 0;｝｀｀｀性能比较：在插入和删除操作中，顺序表在表头或中间位置操作时需要移动大量元素，时间复杂度较高；而链表只需要修改指针，时间复杂度较低。
数据结构上机实验报告(看
数据结构上机实验报告(看病问题)数据结构上机实验报告题目：一个病人看病模拟程序学生姓名：周瑞楠学生学号：3013216085学院名称：计算机学院专业：计算机科学与技术时间：2014.10.28目录第一章，需求分析 (3)1.1 原题描述 (3)1.2 详细问题的解决方案 (3)1.2.1 解决方案要求 (3)1.2.2 各个环节功能要求 (4)第二章，概要设计 (5)2.1 抽象数据类型 (5)2.2 主要算法描述 (5)2.3 算法分析 (6)第三章，详细设计 (7)3.1 程序代码 (7)第四章，调试分析 (9)第五章，测试分析 (10)第六章，未来展望与思考 (11)第一章需求分析1.1 原题描述请按照如下要求编写一个病人看病模拟程序编写一个程序，反映病人到医院看病，排队看医生的情况。
在病人排队过程中，主要重复两件事：（1）病人到达诊室，将病历本交给护士，拍到等待队列中候诊。
（2）护士从等待队列中取出下一位病人的病例，该病人进入诊室就诊。
1.2详细问题的解决方案1.2.1问题分析要求模拟病人等待就诊这一过程，程序采用菜单方式，其选项及功能说明如下：（1）排队————输入排队病人的病历号，加入到病人排队队列中。
（2）就诊————病人排队队列中最前面的病人就诊，并将其从队列中删除。
（3）查看排队————从队首到队尾列出所有的排队病人的病历号。
（4）不再排队，余下依次就诊————从队首到队尾列出所有的排队病人的病历号，并退出运行。
（5）下班————退出运行。
1.2.2 解决方案要求测试数据及输出如下：1:排队 2：就诊 3：查看排队 4：不再排队，余下依次就诊 5：下班请选择：1 >>输入病历号：11:排队 2：就诊 3：查看排队 4：不再排队，余下依次就诊 5：下班请选择：1 >>输入病历号：21:排队 2：就诊 3：查看排队 4：不再排队，余下依次就诊 5：下班请选择：1 >>输入病历号：31:排队 2：就诊 3：查看排队 4：不再排队，余下依次就诊 5：下班请选择：2 >>病人1就诊1:排队 2：就诊 3：查看排队 4：不再排队，余下依次就诊 5：下班请选择：3 >>排队病人：2 31:排队 2：就诊 3：查看排队 4：不再排队，余下依次就诊 5：下班请选择：1>>输入病历号：41:排队 2：就诊 3：查看排队 4：不再排队，余下依次就诊 5：下班请选择：4>>病人按以下顺序就诊：2 3 41.2.3 各个环节功能要求表1-2.1 环节功能函数功能注意条件及限制规则initQueue（）建立空队列头指针尾指针建立后判断是否为NULL EnQueue() 在队尾插入元素判断节点储存分配是否失败DeQueue () 删除对头元素并返回其值释放被删除的节点删除队尾元素注意改变指针位置ShowQueu输出队列元素e()补充正文：主函数里用switch来表明各种情况下应当调用的函数第二章概要设计2.1 抽象数据类型ADT deletenode{数据对象：D={ai|ai∈ElemSet,i=1,2,…,m, m≥0TermSet 中的每个元素包含一个整数}数据关系：R1={<ai ,ai-1>| ai，ai-1∈D,且ai中的整数有序，i=2,3…,n}约定其中a1端为队列投，an 端为队列尾基本操作：InitQueue(&Q);操作结果：建立空队列。
数据结构与程序设计上机实验
数据结构与程序设计上机实验在计算机科学的学习中，数据结构与程序设计是非常重要的基础课程。
而与之相辅相成的上机实验，则是将理论知识转化为实际能力的关键环节。
上机实验为我们提供了一个亲自动手实践的机会，让我们能够更深入地理解数据结构和程序设计的概念。
在实验过程中，我们不再仅仅是纸上谈兵，而是真正地去操作、去实现、去验证。
首先，我们来谈谈数据结构。
数据结构就像是一个仓库，用来存放和组织各种数据。
常见的数据结构有数组、链表、栈、队列、树和图等。
在实验中，我们会亲自创建和操作这些数据结构。
比如说数组，它是一种简单但基础的数据结构，就像是一排连续的盒子，每个盒子里都能存放一个数据。
通过实验，我们可以深刻地理解数组的优点，比如可以快速地随机访问元素。
但同时，我们也能体会到它的局限性，比如插入和删除元素时的复杂性。
链表则与数组有所不同。
它就像是一串珠子，每个珠子（节点）都包含数据和指向下一个节点的指针。
链表在插入和删除元素时相对灵活，但查找元素的效率相对较低。
在实验中，我们会编写代码来实现链表的创建、遍历、插入和删除操作，从而更直观地感受它的特点。
栈和队列也有着各自独特的性质。
栈就像是一个只能从一端进出的筒子，遵循着“后进先出”的原则。
队列则像排队买票的队伍，先到的先服务，遵循“先进先出”的原则。
通过实际编写代码实现栈和队列的功能，我们能更好地理解它们在解决实际问题中的应用场景。
接下来再说说程序设计。
程序设计是一种思考和解决问题的方法，它教会我们如何将一个复杂的问题分解成一个个小的、可解决的部分，并通过代码将这些部分组合起来，实现最终的目标。
在实验中，我们会遇到各种各样的问题。
比如，如何设计一个算法来对一组数据进行排序？冒泡排序、选择排序、插入排序等不同的排序算法各有特点，我们需要通过实验来比较它们的效率和适用场景。
又比如，如何查找一个特定的数据在给定的数据结构中？这就涉及到查找算法，像顺序查找、二分查找等。
通过实际编写和测试这些算法，我们能更清楚地知道在不同情况下应该选择哪种查找方法。
数据结构实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中的重要基础课程，通过实验可以更深入地理解和掌握数据结构的概念、原理和应用。
本次实验的主要目的包括：1、熟悉常见的数据结构，如链表、栈、队列、树和图等。
2、掌握数据结构的基本操作，如创建、插入、删除、遍历等。
3、提高编程能力和解决实际问题的能力，能够运用合适的数据结构解决具体的问题。
二、实验环境本次实验使用的编程语言为C+＋，开发环境为Visual Studio 2019。
三、实验内容1、链表的实现与操作单向链表的创建、插入和删除节点。
双向链表的实现和基本操作。
循环链表的特点和应用。
2、栈和队列的实现栈的后进先出特性，实现入栈和出栈操作。
队列的先进先出原则，完成入队和出队功能。
3、树的操作二叉树的创建、遍历（前序、中序、后序）。
二叉搜索树的插入、查找和删除操作。
4、图的表示与遍历邻接矩阵和邻接表表示图。
深度优先搜索和广度优先搜索算法的实现。
四、实验步骤及结果1、链表的实现与操作单向链表：首先，定义了链表节点的结构体，包含数据域和指向下一个节点的指针域。
通过创建链表头节点，并使用循环依次插入新节点，实现了链表的创建。
插入节点时，根据指定位置找到插入点的前一个节点，然后修改指针完成插入操作。
删除节点时，同样找到要删除节点的前一个节点，修改指针完成删除。
实验结果：成功创建、插入和删除了单向链表的节点，并正确输出了链表的内容。
双向链表：双向链表节点结构体增加了指向前一个节点的指针。
创建、插入和删除操作需要同时维护前后两个方向的指针。
实验结果：双向链表的各项操作均正常，能够双向遍历链表。
循环链表：使链表的尾节点指向头节点，形成循环。
在操作时需要特别注意循环的边界条件。
实验结果：成功实现了循环链表的创建和遍历。
2、栈和队列的实现栈：使用数组或链表来实现栈。
入栈操作将元素添加到栈顶，出栈操作取出栈顶元素。
实验结果：能够正确进行入栈和出栈操作，验证了栈的后进先出特性。
数据结构上机实验报告
数据结构上机实验报告1. 实验目的本次实验旨在通过编写程序，掌握和理解常见的数据结构及其应用。
2. 实验环境与工具- 操作系统：Windows 10- 开发语言：C++- 集成开发环境（IDE）：Visual Studio Code3. 实验内容及步骤3.1 线性表操作演示程序设计与分析步骤：a) 设计一个线性表类，并包含以下基本功能：i) 初始化线性表；ii) 插入元素到指定位置；iii) 删除指定位置的元素；iv) 获取指定位置处的元素值。
b）使用该线性表类进行一系列测试，验证各个功能是否正常运行。
记录并分析每个函数调用所消耗时间以评估算法效率。
3.2 栈和队列综合应用设计与模拟步骤:a）根据给出问题需求，在已有栈、队列等相关代码基础上完成如下任务：i）利用两个堆栈来模拟浏览器前进后退功能;ii）使用循环链式存储结构表示双向链队, 并对其进行初始化、入队、出队等操作。
b). 运行以上代码片段，并输出相应结果。
同时分析算法的时间复杂度和空间复杂度。
4. 实验结果与讨论a) 线性表操作演示程序设计与分析实验结果：- 初始化线性表所需时间为X秒；- 插入元素到指定位置平均耗时Y毫秒；- 删除指定位置的元素平均耗时Z毫秒。
b）栈和队列综合应用设计与模拟实验结果：i) 浏览器前进后退功能测试：共浏览N个网页，前进M 次、后退K次。
运行总体消耗时间T1;ii) 双向链队初始化、入队、出对等操作测试: 共进行P 组数据处理, 运行总体消耗时间T2.5. 结论通过本次上机实验，我们掌握了线性表及其相关基本操作，并且成功完成了栈和队列在特定场景下的应用。
同时，在代码编写过程中也深刻理解并评估了各种算法效率。
6. 致谢感谢老师们给予我宝贵意见以及同学们之间相互交流合作提供支持。
7. 附件8. 法律名词及注释在此处添加涉及到的法律名词或术语，并提供简要注释。
数据结构上机报告
Practice Report for Data Structures and Algorithm AnalysisData Structures Course ReportCandidate:Student Number:Major : Communication EngineeringSupervisor : Wu rangzhongChina University of Geosciences(Wuhan)Wuhan, Hubei 430074, P. R. ChinaDecember 31, 2013链表实现线性表一、实验目的与要求1、实现单链表的建立；2、掌握单链表的插入、删除和查找运算；3、熟练进行C语言源程序的编辑调试。
二、实验内容（1）建立带表头结点的单链表；首先输入结束标志，然后建立循环逐个输入数据，直到输入结束标志。
（2）输出单链表中所有结点的数据域值；首先获得表头结点地址，然后建立循环逐个输出数据，直到地址为空。
（3）输入x,y在第一个数据域值为x的结点之后插入结点y，若无结点x，则在表尾插入结点y;建立两个结构体指针，一个指向当前结点，另一个指向当前结点的上一结点，建立循环扫描链表。
当当前结点指针域不为空且数据域等于x的时候，申请结点并给此结点数据域赋值为y，然后插入当前结点后面，退出函数；当当前结点指针域为空的时候，申请结点并给此结点数据域赋值为y，插入当前结点后面，退出函数。
（4）输入k，删除单链表中所有的结点k，并输出被删除结点的个数。
建立三个结构体指针，一个指向当前结点，另一个指向当前结点的上一结点，最后一个备用；建立整形变量l=0；建立循环扫描链表。
当当前结点指针域为空的时候，如果当前结点数据域等于k，删除此结点，l++，跳出循环，结束操作；如果当前结点数据域不等于k，跳出循环，结束操作。
当当前结点指针域不为空的时候，如果当前结点数据域等于k，删除此结点，l++，继续循环操作；如果当前结点数据域不等于k，指针向后继续扫描。
数据结构集中上机过桥问题详细实验报告
数据结构项目集中上机实践报告姓名：学号：班级：学院：计算机科学与技术专业：计算机科学与技术指导老师：1．实验题目三件有制约关系物品过河问题（80分）有一人要将自己的兔子、蔬菜和狐狸等三件物品运过河。
但过河所用的船每次只能装其中的两件，而这三件物品之间又存在一定的制约关系：兔子不能单独和狐狸以及不能和蔬菜在一起，因为狐狸要吃兔子，兔子也能吃蔬菜。
试构造出问题模型，并编程实现这一问题的求解。
2.数据结构及其存储结构(1)选择对应的数据结构，用图来解决。
(2)选择存储结构，由于问题的规模很小，且总的状态种类很少，所以，我选择邻接矩阵作为图的存储结构。
3.算法的基本思想及分析对象：农夫farmer,狐狸fox,兔子rabbit,蔬菜vegetable。
兔子不能单独和狐狸以及不能和蔬菜在一起，因为狐狸要吃兔子，兔子也能吃蔬菜，如图：农夫兔子狐狸蔬菜算法的思想其实很简单，首先在创建结点，利用is_safe()函数将不安全的结点全部排除，再利用is_connected（）函数得到每个结点的后继结点。
之后利用深度优先搜索可以找到实现这一问题的路径。
问题的分析：①每一个物体都只有两个状态，在原岸或者在对岸；②不同的状态,如农夫和羊在对岸,狼和白菜在原岸；③从一个状态安全地转到另外几个状态，如农夫自己过河或农夫带着羊过河；④不安全状态，如农夫在对岸,其他东西在原岸；⑤初始状态(都在原岸)，结束状态集(都在对岸)。
建立模型：首先，采用二进制中的0/1表示每一个物体的两种状态，用一个四位的二进制数表示一种整体的状态，这样就使原来的问题变的更加易于理解，有利于我们找到合适的数据结构类型来实现问题。
根据对象的状态分为过河（1）和不过河（0），此对象集合就构成了一个状态空间。
问题关键是在这个状态空间内寻找一条从开始状态到结束状态都安全的路径。
其初始状态为四个对象都不过河（都为0），结束状态为四对象全部过河（都是1）。
从一个状态到另一个状态，这其中可以根据相互之间的制约关系，排除不安全的状态，得到安全的路径。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构上机实验报告学院：电子工程学院专业：信息对抗技术姓名：学号：教师：饶鲜日期：目录实验一线性表................................................. - 4 -一、实验目的................................................ - 4 -二、实验代码................................................ - 4 -三、实验结果............................................... - 14 -四、个人思路............................................... - 15 -实验二栈和队列.............................................. - 15 -一、实验目的............................................... - 15 -二、实验代码............................................... - 16 -三、实验结果............................................... - 24 -四、个人思路............................................... - 25 -实验三数组.................................................. - 26 -一、实验目的............................................... - 26 -二、实验代码............................................... - 26 -三、实验结果............................................... - 28 -四、个人思路............................................... - 28 -实验四树.................................................... - 29 -一、实验目的............................................... - 29 -二、实验代码............................................... - 29 -三、实验结果............................................... - 39 -四、个人思路............................................... - 39 -实验一线性表一、实验目的1．熟悉线性表的顺序和链式存储结构2．掌握线性表的基本运算3．能够利用线性表的基本运算完成线性表应用的运算二、实验代码1．设有一个线性表E={e1, e2, … , e n-1, e n}，设计一个算法，将线性表逆置，即使元素排列次序颠倒过来，成为逆线性表E’={ e n, e n-1 , … , e2 , e1 }，要求逆线性表占用原线性表空间，并且用顺序表和单链表两种方法表示，分别用两个程序来完成。
（文件夹：习题1）代码：单链表代码：//单链表逆置主文件.cpp#include<iostream.h>#include<stdio.h>#include"单链表结构类型定义.h"#include"建立单链表.h"#include"输出单链表.h"#include"单链表逆置.h"void main(){linklist*head;creat(head);print(head);invert(head);//调用单链表逆置的函数 print(head);}//单链表结构类型定义.htypedef char datatype;typedef struct node{datatype data;struct node *next;}linklist;//建立单链表.hvoid creat(linklist*&head)//采用尾插法建立具有结点的单链表{char ch;linklist *s,*r;head=new linklist;r=head;while((ch=getchar())!='*'){s=new linklist;s->data=ch;r->next=s;r=s;}r->next=NULL;}//输出单链表.hvoid print(linklist *head) {linklist*p=head->next;while(p!=NULL){cout<<p->data<<" ";p=p->next;}cout<<endl;}//单链表逆置.hvoid invert(linklist*head) {linklist*p,*q,*r;p=head->next;q=p->next;while(q!=NULL){r=q->next;q->next=p;p=q;q=r;}head->next->next=NULL;head->next=p;}单链表结果截图见下方实验结果。
顺序表代码：//顺序表逆置主文件.cpp#include<iostream.h>#include<stdio.h>#include"顺序表结构类型定义.h" #include"建立顺序表.h"#include"输出顺序表.h"#include"顺序表逆置.h"void main(){sequenlist*L;creat(L);print(L);invert(L);//调用顺序表逆值的函数 print(L);}//顺序表的结构类型定义.htypedef char datatype;const int maxsize=1024;typedef struct{ datatype data[maxsize];int last;}sequenlist;//建立顺序表.hvoid creat(sequenlist*&L){L=new sequenlist;L->last=0;char ch;while((ch=getchar())!='*') {L->data[L->last]=ch;L->last++;}}//输出顺序表.hvoid print(sequenlist*L){for(int i=0;i<L->last;i++)cout<<L->data[i]<<" ";cout<<endl;}//顺序表逆置.hvoid invert(sequenlist*L){char mid;int i,j;i=0;j=L->last-1;while(i<j){mid=L->data[i];L->data[i]=L->data[j];L->data[j]=mid;i++;j--;}}顺序表实验截图见下方实验结果。
2．已知由不具有头结点的单链表表示的线性表中，含有三类字符的数据元素（字母、数字和其他字符），试编写算法构造三个以循环链表表示的线性表，使每个表中只含有同一类的字符，且利用原表中的结点空间，头结点可另辟空间。
（文件夹：习题2）代码：//分解单链表主程序文件.cpp#include<iostream.h>#include<stdio.h>#include"单链表结构类型定义.h"#include"建立单链表.h"#include"输出单链表.h"#include"输出循环链表.h"#include"在循环链表中插入.h"#include"分解单链表.h"void main(){ linklist *head,*letter,*digit,*other;creat(head);print1(head);letter=new linklist;letter->next=letter;digit=new linklist;digit->next=digit;other=new linklist;other->next=other;resolve(head,letter,digit,other);//调用分解单链表的函数 print2(letter);print2(digit);print2(other);}//单链表结构类型定义typedef char datatype; typedef struct node{ datatype data;struct node *next;}linklist;void creat(linklist*&head) //建立单链表{ datatype x;linklist *s,*r;head=new linklist;r=head;cin>>x;while(x!='$'){s=new linklist;s->data=x;r->next=s;r=s;cin>>x;}r->next=NULL;}void print1(linklist*head)//输出单链表{ linklist *p=head->next;while(p!=NULL){ cout<<p->data;p=p->next;}cout<<endl;}void print2(linklist*head)//输出循环链表{ linklist *p=head->next;while(p!=head){ cout<<p->data;p=p->next;}cout<<endl;}//在循环链表中插入.hvoid insert(linklist*h,linklist*p) { linklist *q=h;while(q->next!=h) q=q->next;q->next=p;p->next=h;}//分解单链表.hvoid resolve(linklist* head,linklist* letter,linklist* digit,linklist* other) {linklist* p = head->next,*t;head->next =NULL;while (p!=NULL){t = p; p=p->next;if (t->data >='0' && t->data <='9')insert(digit,t);else if ((t->data >='a' && t->data <='z') ||(t->data >='A' && t->data <='Z'))insert(letter,t);else insert(other,t);}return;}截图见下方实验结果。