数据结构上机实验报告
上机实验报告(精选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、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 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;}截图见下方实验结果。