线性表(约瑟夫问题、有序表合并)数据结构实验报告
约瑟夫问题实验报告
![约瑟夫问题实验报告](https://img.taocdn.com/s3/m/f6e2a3f54693daef5ef73d4b.png)
X X X X X X X X实验报告课程:数据结构班级:姓名:学号:成绩:指导教师:实验日期:2012.3实验密级:预习程度:实验时间:仪器组次:必修/选修:必修实验序号:01实验名称:线性结构的应用——约瑟夫问题实验目的与要求:编程实现约瑟夫问题。
假设有n个人围圈而坐,现在从第k人开始数数,数到m的人出列,紧接着的后续人又从1开始数数,到m出列,如此重复下去,直到全体人员出列。
编程实现新出列的数字序号输出。
实验仪器:名称型号数量微机1一、概要设计本程序使用了循环链表这一数据结构。
循环链表在普通链表的基础上,将最后一个节点的指针域指向头结点。
具体定义为:typedef struct CLNode{ int data;struct CLNode *next;}Node;//定义单向循环链表结构体,并令最后一个指针指向头结点流程图如下:注:在*处调用子函数为head 分配存储空间,如果内存不够,结束程序 head=head->next; head->data=i; i++; head==NULL? i<=n? 为p 分配存储空间,如果内存不够,结束程序 pr->next=p;p->data=i; p->next=head; pr=p; 开始 从主函数中接受头结点指针head ,n i=1,Node *p=NULL , Node *pr=head; 返回head 是是否 否图2——子函数:建立n 阶循环链表,返回链表的头指针图1——主函数开始 输入总人数(n)、从第几个人开始数(k)、数到第几个人出列(m) 构造n 项循环链表*执行”head=head->next ”k 次,修改头指针指向Node *head=NULL;int i=0; 按顺序输出? 否 是是否 结束释放链表剩余存储空间 输出head->data 实现报数并出列* head!=head->ne xt?直接按顺序输出开始从主函数中接受head和mint i=1;Node *p=head;Node *pre=NULL;执行:”pre=p;p=p->next;”m次,模拟报数并移动指针此时,p->data便是出列编号,输出其值删除p指向的节点,令p之后的节点为head返回head图3——子函数:当链表中的结点个数大于1,调用此函数,实现目标出列,并删除该节点,另该节点下一结点为头结点,返回修改后的头结点二、详细设计本程序核心算法主要有两部分:一是建立循环链表,二是实现目标人员的出列。
数据结构实验报告
![数据结构实验报告](https://img.taocdn.com/s3/m/3a75820f763231126edb11c7.png)
姓名:学号:班级:2010年12月15日实验一线性表的应用【实验目的】1、熟练掌握线性表的基本操作在顺序存储和链式存储上的实现。
、;2、以线性表的各种操作(建立、插入、删除、遍历等)的实现为重点;3、掌握线性表的动态分配顺序存储结构的定义和基本操作的实现;4、通过本章实验帮助学生加深对C语言的使用(特别是函数的参数调用、指针类型的应用和链表的建立等各种基本操作)。
【实验内容】约瑟夫问题的实现:n只猴子要选猴王,所有的猴子按1,2,…,n编号围坐一圈,从第一号开始按1,2…,m报数,凡报到m号的猴子退出圈外,如此次循环报数,知道圈内剩下一只猴子时,这个猴子就是猴王。
编写一个程序实现上述过程,n和m由键盘输入。
【实验要求】1、要求用顺序表和链表分别实现约瑟夫问题。
2、独立完成,严禁抄袭。
3、上的实验报告有如下部分组成:①实验名称②实验目的③实验内容:问题描述:数据描述:算法描述:程序清单:测试数据算法:#include <stdio.h>#include <stdlib.h>typedef struct LPeople{int num;struct LPeople *next;}peo;void Joseph(int n,int m) //用循环链表实现{int i,j;peo *p,*q,*head;head=p=q=(peo *)malloc(sizeof(peo));p->num=0;p->next=head;for(i=1;i<n;i++){p=(peo *)malloc(sizeof(peo));p->num=i;q->next=p;p->next=head;}q=p;p=p->next;i=0;j=1;while(i<n){if(j%m==0){q->next=p->next;p=q->next;printf("%4d",j%n);i++;}else{q=p;p=p->next;}j++;}printf("\n");}void main(){int n,m; /*人的个数*/printf("Please Enter n amd m(n>m):\n");scanf("%d%d",&n,&m);Joseph(n,m);}实验二树和图的应用【实验目的】1.熟练掌握数的基本概念、二叉树的基本操作及在链式存储结构上的实现。
约瑟夫环数据结构实验报告
![约瑟夫环数据结构实验报告](https://img.taocdn.com/s3/m/41bb970b842458fb770bf78a6529647d272834e5.png)
数据结构上机实验报告1、需求分析1:用一个循环链表实现n个人按顺时针排成一圈,每个人看作一个节点,每个节点都是一个结构体类型,包含三个域: 序号域(data), 密码域(key),指向下一个人的指针域(next).2:程序开始时由用户任意输入人数n及一个正整数作为报数上限值m,一个正整数作为密码最大值,判断所输密码是否在范围内。
然后为依次每一个人指定一个密码3:初始密码为用户外部输入的密码m, 从第一个人开始按顺市针方向自1开始报数.,报道m的时停止,报m的人出列,将他的密码作为新的密码值(m), 从他在顺针方向的下一个人开始重新从1报数,如此下去,直至所有的人全部出列为止.4:本程序最终结果为n 的人的出列顺序5:测试数据: m的初值为1; n =5(即有5个人)57个人的密码依次为:1,2,3,4,5.首先没的值为1,正确的出列顺序应为1,2,4,3,5。
2概要分析(1)抽象数据类型的定义:为实现上述程序的功能,可以用整数存储用户的输入。
并将用户输入的值存储于线性表中。
算法的基本思想:约瑟夫环问题中的数据是人所在的位置,而这种数据是存在“第一元素、最后元素”,并且存在“唯一的前驱和后继的”,符合线性表的特点。
由于需要模拟约瑟夫环的出列问题,可以采用顺序表来实现线性表,完成出列顺序的输出。
核心算法主要分为两步:1、确定需要删除的位置,2、设置并删除该位置。
已知报数间隔m,我们可以把当前位置加上m获得需要删除的位置,如果获得的位置超过顺序表中实际元素的总长度,则可以通过减去数组的实际长度来修正(即模拟环状计数)。
然后把顺序表中的当前指向位置设置为该位置,继而删掉该位置。
反复进行上述确定位置和删除位置的操作,直到顺序表为空。
(2)主程序的流程:程序由三个模块组成:(1)输入模块:无提示语句,直接输入总人数n和报数次数m,中间用逗号隔开。
(2)构造链表并输入每个人信息模块:(3)主要处理出列的函数:分别在DOS下和文件中,按移除元素的顺序依次显示其位置。
约瑟夫问题——线性表部分.数据结构实验报告
![约瑟夫问题——线性表部分.数据结构实验报告](https://img.taocdn.com/s3/m/30669316866fb84ae45c8d11.png)
2010级数据结构实验报告实验名称:实验一——线性表(约瑟夫问题)学生姓名:在这我就不写了班级:**班内序号:**学号:**日期:2010年11月4日1.实验要求一、实验目的通过实现约瑟夫问题,掌握如下内容:1、熟悉C++语言的基本编程方法,掌握集成编译环境的调试方法;2、学习指针、模板类、异常处理的使用;3、掌握线性表的操作实现方法;4、培养使用线性表解决实际问题的能力。
二、实验内容利用循环链表实现约瑟夫问题的求解。
约瑟夫问题如下:有n个人(n>=1)围坐在一个圆桌周围,把这n个人依次编号为1,…,n。
从编号是1的人开始报数,顺时针数到m的那个人出列,他的下一个然后从出列的下一个人重新开始报数,数到第m个人又出列,…,如此反复直到所有的人全部出列。
请问最后一个出列的人的编号。
2. 程序分析对于这个程序来说,首先要确定构造链表时所用的插入方法。
当数到m时一个人就出列,也即删除这个节点,同时建立这个节点的前节点与后节点的联系。
由于是循环计数,所以才采用循环列表这个线性表方式。
在这个程序中解决了存储问题后,之后最大的难点就是关于出列节点的逻辑判断。
由于我插入元素时是将rear指针中也存入了元素值,又增加了一个front指针,实际上是front 指针始终存在而rear指针有可能消除。
这样遇到的问题就是,假设p本身就是rear指针,那当移到下一位时就应该移动两位来跳过front这一个空节点。
这个是程序实现中容易发生逻辑错误的地方。
2.1 存储结构本实验中所用的存储结构为单链表。
以下即为单链表的存储结构示意图:front(2)非空单循环链表2.2 关键算法分析1、关键算法:(1)、插入:在把元素插入到循环链表中时,由于是采用的头插法,所以我保留了front头结点。
在每加入一个节点时,都会直接连接在front后面,从而保证一开始就赋值的rear尾节点不用修改。
伪代码阐释如下:1)、在堆中建立新节点:Node<T> *s=new Node<T>;2)、将a[i]写入到新节点的数据域:s->data=a[i];3)、修改新节点的指针域:s->next=front->next;4)、修改头结点的指针域,将新节点加入到链表中:front->next=s;时间复杂度为:1;(2)、删除:首先通过p指针查找到所要删除的节点的前一个节点,继而通过q=p->next简单地删除掉。
数据结构实验一 约瑟夫环问题实验报告电子版
![数据结构实验一 约瑟夫环问题实验报告电子版](https://img.taocdn.com/s3/m/43258d64fe4733687e21aa63.png)
for(i = 1;i<length;i++){
tmp = (Node *)malloc(sizeof(Node));
tmp->number = num[i];
tmp->pass = pas[i];
pri->next = tmp;
pri = tmp;
pri->next = head;
for(i=0;i<time;i++){ //找到要删除的结点
tmp = tmp->next;
}
printf("%d ",tmp->number);
timeห้องสมุดไป่ตู้= tmp->pass - 1;
deleteFromList(&head,tmp);//删除结点
tmp = tmp->next;//从下一个结点又开始计算
initList(head);
createFromTail(head,num,pas,sizeof(num)/sizeof(num[0]));
p = head;
printf("\n约瑟夫计数前,每个数和他的密码:\n");
for(i = 0;i<sizeof(num)/sizeof(num[0]);i++){
}
}
// 从链表中删除
void deleteFromList(List *head,Node *tmp)
{
Node *tmp1;
Node *tmp2;
tmp1 = *head;
tmp2 = tmp1;
//如果链表剩了一个元素
数据结构约瑟夫环实习报告
![数据结构约瑟夫环实习报告](https://img.taocdn.com/s3/m/f2dea3594b7302768e9951e79b89680203d86b2c.png)
数据结构约瑟夫环实习报告一、实习题目约瑟夫环(Josephus Problem)是一种经典的问题,编号为1,2,……,n的n个人按顺时针方向围坐一圈,每人持有一个密码(正整数)。
一开始任选一个正整数作为报数上限值M,从第一个人开始按顺时针方向自1开始顺序报数,报到M时停止报数。
报M的人出列,将他的密码作为新的M值,从他在顺时针方向上的下一个人开始重新从1报数,如此下去,直至所有人全部出列为止。
试设计一个程序求出出列顺序,并利用单向循环链表存储结构模拟此过程,按照出列的顺序输出各人的编号。
二、实习目的1. 熟悉单向循环链表的存储结构及其应用。
2. 加深对线性链表这种数据结构的基本概念理解。
3. 锻炼较强的思维和动手能力,更加了解编程思想和编程技巧。
三、实习内容1. 采用单向循环链表实现约瑟夫环。
2. 从键盘输入整数m,通过create函数生成一个具有m个结点的单向循环链表。
3. 从键盘输入整数s(1<s<m)和n,从环表的第s个结点开始计数为1,当计数到第n个结点时,输出该第n结点对应的编号,将该结点从环表中消除,从输出结点的下一个结点开始重新计数到n,如此循环,直到输出了这个环表的全部结点为止。
四、程序设计1. 概要设计为了解决约瑟夫环的问题,我们可以建立单向循环链表来存储每个人的信息(该人的编号以及其下一个人的编号),及结点,人后通过查找每个结点,完成相应的操作来解决约瑟夫问题。
抽象数据类型定义:数据对象:D数据关系:R1基本操作:操作结果:构造2. 详细设计(1)初始化循环单链表```cvoid initList(LNode *head) {head->next = head;head->number = 0;}```(2)尾插法建立循环单链表```cvoid createFromTail(LNode *head, int m, int pass, int length) { LNode *p = head;int i;for (i = 1; i <= m; i++) {LNode *s = (LNode *)malloc(sizeof(LNode));s->number = i;s->pass = pass;s->next = NULL;p->next = s;p = s;}p->next = head; // 使链表形成一个环}```(3)从链表中删除结点```cvoid deleteFromList(LNode *head, LNode *p) {if (p->next == head) { // 删除的是头结点head = p->next;}p->next = p->next->next;free(p);}```(4)约瑟夫计数```cvoid yuesefu(LNode *head, int m, int n, int *sequence) { int count = 0;LNode *p = head;while (p->next != p) { // 当链表中还有多个结点时循环 count = 0;LNode *q = p->next;while (count < n) {q = q->next;count++;}sequence[count] = q->number; // 记录下出列的人的编号deleteFromList(head, q); // 删除该结点p = q->next; // 从下一个结点又开始计算n = m; // 新的M值}}```五、实验结果与分析通过以上程序设计,我们可以得到约瑟夫环的出列顺序。
数据结构实验一约瑟夫(Joseph)问题
![数据结构实验一约瑟夫(Joseph)问题](https://img.taocdn.com/s3/m/ef7477a8dd3383c4bb4cd218.png)
华北#########学院数据结构实验报告2011~2012学年第二学期级计算机专业班级:学号:姓名:实验一线性表及其应用一、实验题目:线性表及其应用——约瑟夫环二、实验内容:1.设带头结点的单链表ha和hb中结点数据域值按从小到大顺序排列,且各自链表内无重复的结点,要求:(1)建立两个按升序排列的单链表ha和hb。
(2)将单链表ha合并到单链表hb中,且归并后的hb链表内无重复的结点,结点值仍保持从小到大顺序排列。
(3)输出合并后单链表hb中每个结点的数据域值。
代码:实验结果:struct Node{ int data;Node* next; };typedef Node Slink;void create(Slink* h);void show(Slink* h);void merge(Slink* ha,Slink* hb);#include<iostream.h>void main(){cout<<"创建链表ha"<<endl;Slink ha; ha.next =NULL;create(&ha);cout<<"链表ha的节点排列"<<endl;show(&ha);cout<<endl;cout<<"创建链表hb"<<endl;Slink hb; hb.next =NULL;create(&hb);cout<<"链表hb的节点排列"<<endl;show(&hb);cout<<endl;cout<<"合并后链表hb的节点排列"<<endl;merge(&ha,&hb);show(&hb);}void create(Slink* h){if(!h) return;int n=0;//节点总数int j=0;//累计创建结点个数cout<<"请输入创建节点的个数"<<endl;cin>>n;Node* F=h;//F始终指向tou节点Node* pre=h;//pre始终指向要插入位置的前一个节点while(j<n){Node* p=new Node;cout<<"请输入节点的数据"<<endl;cin>>p->data;//链表为空时if(!F->next ){ F->next =p;p->next =NULL;j++;continue;}//链表不空时while(pre->next ){ if(p->data <pre->next ->data ){ p->next =pre->next ;pre->next =p;pre=h;j++;break;}else if (p->data ==pre->next ->data){ cout<<"该值已存在,请重新输入"<<endl;break;}pre=pre->next ;}if(!pre->next ){ pre->next =p;p->next =NULL;j++;}}}void merge(Slink* ha,Slink* hb){ //p遍历ha,q遍历hbNode * p=ha->next ;Node * q=hb->next ;//pw始终指向新生成链表的最后一个结点Node * pw=hb;while(p&&q){ if((p->data)<(q->data)){ pw->next=p;p=p->next;pw=pw->next;continue;}if((p->data)>(q->data)){ pw->next=q;q=q->next;pw=pw->next;continue;}if((p->data)==(q->data)){ pw->next=q;p=p->next;q=q->next;pw=pw->next;continue;}}while(p){ pw->next=p;p=p->next;pw=pw->next;}while(q){ pw->next=q;q=q->next;pw=pw->next;}pw->next=NULL;}void show(Slink* h){Node* p=h->next ;while(p ){ cout<<p->data <<" ";p=p->next ;}cout<<endl;}2.约瑟夫(Joseph)问题。
数据结构__约瑟夫环问题__实习报告
![数据结构__约瑟夫环问题__实习报告](https://img.taocdn.com/s3/m/a2e49457be23482fb4da4c4c.png)
实验报告实验一线性表的基本操作及其应用一、实验目的1、复习C语言程序设计中的知识。
2、熟悉线性表的逻辑结构。
3、熟悉线性表的基本运算在两种存储结构上的实现,其中以熟悉链表的操作为侧重点。
二、实验内容本次实验提供2个题目,如果实现第一个题目有困难,可做第二个题目题目一:约瑟夫环[问题描述]约瑟夫(Joseph)问题的一种描述是:编号为1,2,…,n的n个人按顺时针方向围坐一圈,每人可有代表本人的序号。
一开始任选一个正整数m,从第一个人开始按顺时针方向自1开始顺序报数,报到m时停止报数。
报m的人出列,从他在顺时针方向上的下一个人开始重新从1报数,如此下去,直至所有人全部出列为止。
试设计一个程序求出出列顺序。
[基本要求]利用单向链表存储结构模拟此过程,按照出列的顺序印出各人的编号。
[测试数据]由学生任意指定。
如:m的初值为5;n的值为7;序号:3,1,7,2,4,8,4;(报告上要求写出多批数据测试结果)[实现提示]程序运行后首先要求用户输入初始报数m,人数n,(设n≤30)。
然后输入各人的序号。
[选作内容]向上述程序中添加在顺序结构上实现的部分实验题目一:约瑟夫环一.需求分析1.利用单向循环链表存储结构模拟此过程,按照出列的顺序印出各人的编号。
2.演示程序以用户和计算机的对话方式执行,即在计算机上显示“提示信息”之后,由用户在键盘上输入演示程序中规定的运算命令;相应的输入数据(滤去输入中的非法字符)和运算结构显示在其后。
3.程序执行的命令包括:1)输入报数上限值;2)输入人数以及所持密码;3)输出出列顺序;4)结束2)测试数据4.由学生任意指定。
如:m的初值为5;n的值为7;序号:3,1,7,2,4,8,4;二.概要设计为实现上述程序功能,需建立单向循环链表以存储此结构。
为此,需要一个抽象数据结构类型。
1.链表结点的抽象数据类型定义为:ADT2.本程序包含三个模块:3)主程序模块;4)循环链表的创建模块——实现创建循环链表;5)出列操作的模块——实现最终的出列操作;各模块之间的调用关系如下:出列操作的模块<——主程序模块——>循环链表的创建模块三.详细设计1.元素类型,结点类型和指针类型struct Lnode{int password;struct Lnode *next;};typedef struct Lnode *LinkList;2. 子函数1,创建循环链表int Creatlist_L(LinkList &head,int n)程序的实现:int Creatlist_L(LinkList &head,int n){//利用引用调用得到头指针head;int i;LinkList p,q;printf("请依次输入各位密码:");for(i=1;i<=n;i++){if(i==1){//申请一个空间,将头指针head和指针p均指向第一个结点;head=p=(LinkList)malloc(sizeof(struct Lnode));if(p==0) return 0; //分配存储空间失败}else{q=(LinkList)malloc(sizeof(struct Lnode));if(q==0) return 0;p->next=q;//通过next将下一个结点和前一个结点连起来;p=q;}scanf("%d",&(p->password));//一次输入对应的密码;}p->next=head;//构成循环链表,并返回链表的头指针return 0;}void DeleteNode(LinkList head,int m,int n){LinkList p,q;int j,i;p=head;for(j=1;j<n;j++){//先出列前n-1个人,并依次释放其结点的空间;for(i=1;i<m;i++,p=p->next);//寻找第m个人;printf("%d ",p->password);p->password=p->next->password;//将后一个结点的数据全部赋值于当前p所指的结点q=p->next;p->next=p->next->next;//p指向其下一个的下个一结点,重新开始寻找;free(q);}printf("%d",p->password);//最后一个人出列,并释放其结点所占空间;free(p);} }scanf("%d",&(p->password));//一次输入对应的密码;}p->next=head;//构成循环链表,并返回链表的头指针return 0;}3.主函数的实现,对两个子函数的调用void main(){int n,m;LinkList List;printf("输入人数:");scanf("%d",&n);printf("输入值m:");scanf("%d",&m);Creatlist_L(List,n);DeleteNode(List,m,n);printf("\n");}4.函数的调用关系图反映了演示程序的层次结构:main——>Creatlist;main——>DeleteNode;四调试分析1.由于对引用调用理解的不透侧,导致刚开始修改了很长时间。
约瑟夫问题数据结构实验报告
![约瑟夫问题数据结构实验报告](https://img.taocdn.com/s3/m/86b2342d6d175f0e7cd184254b35eefdc8d3152a.png)
约瑟夫问题数据结构实验报告实验概述本实验旨在通过实现约瑟夫问题的求解算法,深入理解链表数据结构的应用,以及算法的时间复杂度分析。
实验将通过编写程序来模拟约瑟夫问题,并测试不同规模下的时间性能,从而验证算法的准确性和效率。
实验目的●理解约瑟夫问题的定义和求解算法●掌握链表数据结构的基本操作●理解算法的时间复杂度分析方法实验内容1·约瑟夫问题约瑟夫问题是一个经典的数学问题,描述如下:n个人围成一圈,从第一个人开始报数,报到m的人出圈,然后从出圈的下一个人重新开始报数,直到剩下最后一个人。
2·数据结构设计为了解决约瑟夫问题,我们可以使用循环链表来表示n个人围成的圈。
链表节点的数据域存储每个人的编号,指针域指向下一个人。
3·算法设计约瑟夫问题的求解算法如下:1·创建一个循环链表,并初始化n个人的编号。
2·从第一个人开始,依次报数m次,直到找到第m个人。
3·将第m个人从链表中删除。
4·重复步骤2和3,直到只剩下最后一个人。
4·程序实现下面是约瑟夫问题求解算法的主要实现步骤:1·定义一个循环链表的结构,并实现链表的初始化操作。
2·实现算法的主函数,用于接收输入参数n和m,并调用其他函数进行求解。
3·实现一个函数,用于模拟报数过程,并返回每次报数的人的编号。
4·实现一个函数,用于删除链表中指定位置的节点。
5·实现一个函数,用于遍历链表,输出剩下的最后一个人的编号。
实验结果及分析在实验中我们分别测试了5个人和10个人的情况,对比了不同m值下的运行时间,并绘制了相应的曲线图。
实验结果表明,约瑟夫问题的求解算法在不同规模下的时间复杂度为O(nm),其中n为人数,m为报数值。
随着m值的增大,算法的运行时间也呈指数级增长。
附件本文档所涉及的附件包括:●源代码文件●实验结果数据文件●曲线图文件法律名词及注释本文档没有涉及法律名词及注释。
北邮数据结构实验一_约瑟夫问题_实验报告
![北邮数据结构实验一_约瑟夫问题_实验报告](https://img.taocdn.com/s3/m/f47a786eb307e87101f69682.png)
北京邮电大学电信工程学院数据结构实验报告实验名称:实验一——线性表学生姓名:班级:班内序号:学号:日期:1.实验要求实验目的熟悉C++语言的基本编程方法,掌握集成编译环境的调试方法学习指针、模板类、异常处理的使用掌握线性表的操作的实现方法学习使用线性表解决实际问题的能力实验内容利用循环链表实现约瑟夫问题的求解。
约瑟夫问题如下:已知n个人(n>=1)围坐一圆桌周围,从1开始顺序编号。
从序号为1的人开始报数,顺时针数到m的那个人出列;他的下一个人又从1开始报数,数到m的那个人又出列;依此规则重复下去,直到所有人全部出列。
请问最后一个出列的人的编号。
2. 程序分析2.1 存储结构采用单循环链表实现约瑟夫问题的求解单循环链表存储结构示意图2.2 关键算法分析基本思想:首先,应该确定构造链表时所用的插入方法。
当数到m的那个人就出列,也即删除这个节点,同时建立这个节点的前节点与后节点的联系。
由于是循环计数,所以才采用循环列表方式。
第1页其次还要考虑输入值异常的情况。
之后,就是关于出列节点的逻辑判断。
依次找到待删结点的直接前驱,便于删除结点后修改它的直接后继,如此循环直到最后一个人出列。
关键算法:1.最后一个数据指向头指针,形成循环链表head=new Node; //确定头结点p=head;for(i=1;i<=n-1;i++) //赋初值{p->data=i;p->next=new Node; //为下一个新建内存p=p->next;}p->data=n; //最后一个单独处理p->next=head; //指向头,形成循环链表p=head;2.输入值异常的情况cout<<"请输入环内总人数n:";cin>>n;if (n<1) //考虑n输入错误的情况{cout<<"n值输入错误"<<endl;}cout<<"请输入起始人号码:";cin>>k;if (k<1||k>n) //考虑k输入异常的情况{cout<<"k值输入错误"<<endl;}cout<<"请输入m值:";cin>>m;if (m<1) //考虑m输入异常的情况{cout<<"m值输入错误"<<endl;}3.在约瑟夫环中实现逐个出环并找出最后一个出环的序号while(p!=p->next){for(i=1;i<m-1;i++) //查找q的节点p=p->next;q=p->next;cout<<"第"<<s<<"个出环的人编号是:"<<q->data<<endl;p->next=q->next;北京邮电大学信息与通信工程学院p=p->next;delete q; //释放q的空间s++;}cout<<"最后环内留下的人编号是:"<<p->data<<endl;delete p;算法步骤:①从第一个结点开始,查找第i-1个元素,设为p指向该结点;②设q指向第i个元素:q = p->next;,输出q元素的数据;③摘链,即将q元素从链表中摘除:p->next = q->next;p=p->next;delete q;3. 程序运行结果1、测试主函数流程:流程图如图所示第3页2、程序运行结果3、输入错误运行结果4. 总结在调试程序过程中,虽然没有编译错误,但是运行结果总是和准确值差1,最后发现是把i=1写成i=0,才造成的错误,改过之后就没有问题了。
数据结构实验约瑟夫问题实验报告
![数据结构实验约瑟夫问题实验报告](https://img.taocdn.com/s3/m/a3f3750bd4d8d15abf234e79.png)
数据结构实验报告
课程名称数据结构
实验名称数据结构试验
专业班级
姓名
学号
实验日期第 11 周星期日节
2012—2013学年度第一学期
再输入间隔数4后回车:输入起始位置
输入数据1 2 3 4 5 6 7 8,回车:
筛选后的结果就如屏幕所示
若中途输入的起始位置为9,回车,会提示如下
八、实验小结:
你在编程过程中花时多少?
总共用来将近2小时
多少时间在纸上设计?
大约有半个小时在纸上设计
多少时间上机输入和调试?
45分钟左右
多少时间在思考问题?
剩下的所有时间在思考这些问题
遇到了哪些难题?
如何实现循环的跳出,还有在轮到输出的数据释放后,该如何调整指针来正常继续运行成程序
你是怎么克服的?
我是通过画过几个数组,然后从手工图中得到了思路
你的收获有哪些?
通过这次试验让我对循环结构有了另外的感悟,还有数组的操作逻辑的看法有了很大改变。
数据结构实验报告-线性表
![数据结构实验报告-线性表](https://img.taocdn.com/s3/m/4e959631c1c708a1294a44df.png)
1 线性表1. 实验题目与环境1.1实验题目及要求(1)顺序表的操作利用顺序存储方式实现下列功能:根据键盘输入数据建立一个线性表,并输出该线性表;对该线性表进行数据的插入、删除、查找操作,并在插入和删除数据后,再输出线性表。
(2)单链表的操作利用链式存储方式实现下列功能:根据键盘输入数据建立一个线性表,并输出该线性表;对该线性表进行数据的插入、删除、查找操作,并在插入和删除数据后,再输出线性表。
(3)线性表的应用约瑟夫环问题。
有n个人围坐一圈,现从某个人开始报数,数到M的人出列,接着从出列的下一个人开始重新报数,数到M的人又出列,如此下去,直到所有人都出列为止。
要求依次输出出列人的编码。
2.问题分析(1)顺序表的操作利用一位数组来描述顺序表,即将所有元素一词储存在数组的连续单元中,要在表头或中间插入一个新元素时,需要将其后的所有元素都向后移动一个位置来为新元素腾出空间。
同理,删除开头或中间的元素时,则将其后的所有元素向前移动一个位置以填补空位。
查找元素时,则需要利用循环语句,一一判断直到找出所要查找的元素(或元素的位置),输出相关内容即可(2)单链表的操作利用若干个结点建立一个链表,每个节点有两个域,即存放元素的数据域和存放指向下一个结点的指针域。
设定一个头指针。
在带头结点的单链表中的第i个元素之前插入一新元素,需要计数找到第i-1个结点并由一指针p指向它,再造一个由一指针s指向的结点,数据为x,并使x的指针域指向第i个结点,最后修改第i-1个结点的指针域,指向x结点。
删除第i个元素时,需要计数寻找到第i个结点,并使指针p指向其前驱结点,然后删除第i个结点并释放被删除结点的空间。
查找第i个元素,需从第一个结点开始计数找到第i个结点,然后输出该结点的数据元素。
(3)线性表的应用程序运行之后,首先要求用户指定初始报数的上限值,可以n<=30,此题中循环链表可不设头结点,而且必须注意空表和"非空表"的界限。
数据结构课程设计报告(约瑟夫问题)
![数据结构课程设计报告(约瑟夫问题)](https://img.taocdn.com/s3/m/86829b019b89680202d82504.png)
数据结构课程设计报告(约瑟夫问题)问题描述约瑟夫问题:编号为1-n的n个人围坐圆桌旁,从任一指定编号为k的人开始报数,报数为m的人离开圆桌,下一个人接着从n开始报数, 报数为m的人又离开圆桌,依此重复,直至所有人离开圆桌.编一程序,输出离开圆桌的人的编号序列.设计思想首先采单循环链表建立整个约瑟夫环,手动输入总人数(既链表的长度)、每个人的所持下一轮报数出对值和初始报数值。
node->num为人的编号,node->为此人所持的下一轮报数值。
建立单循环链表后,通过初始报数值找到出列的人,输出node->num的值,然后将该结点中的data值作为下一轮的报数值。
重复以上过程直至所有的人都出列,则程序结束。
主要算法do{k=1;while(k!=m)//当k=m时,结束第一轮报数{p1=p1->next;k++;}//报数中将指针指向下一位p2=p1->next;p1->next=p2->next;//把报数为m的人的结点从链表中删除printf("编号为%d的人出列,他的key%d作为新的m值/n",p2->num,p2->data);//m=p2->data;//报数为m的人的密码作为下一轮新的m值free(p2);//释放报m的人的结点}while(p1->next!=p1);//当p1->指向自己时,报数结束的值加一,当k=m时,此时p1指向人出列,p2指向该结点的上一结点,k为计数器,指针每移动一次,k让上一结点的next指向该结点的下一结点,然后删除该结点。
P1指向该结点下一结点,令k=1,再开始下一轮报数。
等到所有人出列后,循环结束。
for(i=1;i<=n;i++){printf("请输入%d号同学的key",i);scanf("%d",&j);//输入学生所带有的密码p1->next =(listnode*)malloc(sizeof(listnode));//建立一个空间p1=p1->next ;p1->data=j;p1->num=i;//对结点的num和data成员赋值p1->next=head->next; }定义指针p1,然后建立一个新结点并将p1->next指向他,再将地址赋给p1,最后将head->next赋给p1->next,构成了循环单链表,然后让所有人键入链表并给num和data成员赋值。
北邮数据结构实验一_约瑟夫问题_实验报告
![北邮数据结构实验一_约瑟夫问题_实验报告](https://img.taocdn.com/s3/m/f4ae991210a6f524ccbf854a.png)
数据结构实验报告实验名称:实验一——线性表学生姓名:班级:班内序号:学号:日期:1.实验要求实验目的熟悉C++语言的基本编程方法,掌握集成编译环境的调试方法学习指针、模板类、异常处理的使用掌握线性表的操作的实现方法学习使用线性表解决实际问题的能力实验内容利用循环链表实现约瑟夫问题的求解。
约瑟夫问题如下:已知n个人(n>=1)围坐一圆桌周围,从1开始顺序编号。
从序号为1的人开始报数,顺时针数到m的那个人出列;他的下一个人又从1开始报数,数到m的那个人又出列;依此规则重复下去,直到所有人全部出列。
请问最后一个出列的人的编号。
2. 程序分析2.1 存储结构采用单循环链表实现约瑟夫问题的求解单循环链表存储结构示意图2.2 关键算法分析基本思想:首先,应该确定构造链表时所用的插入方法。
当数到m的那个人就出列,也即删除这个节点,同时建立这个节点的前节点与后节点的联系。
由于是循环计数,所以才采用循环列表方式。
其次还要考虑输入值异常的情况。
之后,就是关于出列节点的逻辑判断。
依次找到待删结点的直接前驱,便于删除结点后修改它的直接后继,如此循环直到最后一个人出列。
关键算法:1.最后一个数据指向头指针,形成循环链表head=new Node; //确定头结点p=head;for(i=1;i<=n-1;i++) //赋初值{p->data=i;p->next=new Node; //为下一个新建内存p=p->next;}p->data=n; //最后一个单独处理p->next=head; //指向头,形成循环链表p=head;2.输入值异常的情况cout<<"请输入环内总人数n:";cin>>n;if (n<1) //考虑n输入错误的情况{cout<<"n值输入错误"<<endl;}cout<<"请输入起始人号码:";cin>>k;if (k<1||k>n) //考虑k输入异常的情况{cout<<"k值输入错误"<<endl;}cout<<"请输入m值:";cin>>m;if (m<1) //考虑m输入异常的情况{cout<<"m值输入错误"<<endl;}3.在约瑟夫环中实现逐个出环并找出最后一个出环的序号while(p!=p->next){for(i=1;i<m-1;i++) //查找q的节点p=p->next;q=p->next;cout<<"第"<<s<<"个出环的人编号是:"<<q->data<<endl;p->next=q->next;p=p->next;delete q; //释放q的空间s++;}cout<<"最后环内留下的人编号是:"<<p->data<<endl;delete p;算法步骤:①从第一个结点开始,查找第i-1个元素,设为p指向该结点;②设q指向第i个元素:q = p->next;,输出q元素的数据;③摘链,即将q元素从链表中摘除:p->next = q->next;p=p->next;delete q;3. 程序运行结果1、测试主函数流程:流程图如图所示2、程序运行结果3、输入错误运行结果4. 总结在调试程序过程中,虽然没有编译错误,但是运行结果总是和准确值差1,最后发现是把i=1写成i=0,才造成的错误,改过之后就没有问题了。
线性表实验报告
![线性表实验报告](https://img.taocdn.com/s3/m/c2da50d333d4b14e85246856.png)
LinkList p;
p=L->next;
while(p){
printf("%5d",p->data);
p=p->next;
}
return OK;
}
void main()
{
int i,n,k,d,e;
LinkList La,Lb;
InitList_L(La);
InitList_L(Lb);
e=L.elem[i];
for(j=i;j<=L.length;j++)
L.elem[j]=L.elem[j+1];
L.length--;
return ok;
}
int output(sqlist &L){
int i;
printf("output sqlist data:\n");
for(i=0;i<L.length;i++)
PrintList(La);
printf("\nAfter delete the list is:\n");
ListDelete_L(La,e);
PrintList(La);
printf("\n");
printf("I will insert:");
scanf("%d",&k);
ListInsert_L(La,k);
int a,j,i,m;
CLinkList p,r;
printf("Input the m(m<=20):\nm=");
scanf("%d",&m);
约瑟夫问题数据结构实验报告
![约瑟夫问题数据结构实验报告](https://img.taocdn.com/s3/m/3440862c6d175f0e7cd184254b35eefdc9d3155b.png)
约瑟夫问题数据结构实验报告正文:⒈引言本实验报告旨在探讨约瑟夫问题及其相关数据结构的实现。
约瑟夫问题是一个经典的数学问题,涉及到环形数据结构和循环删除等操作。
通过本次实验,我们将实现约瑟夫问题的求解算法,并对其进行性能分析。
⒉算法描述⑴问题描述约瑟夫问题描述如下:有n个人围成一圈,从某个人开始依次报数,报到m的人出圈,然后从出圈的下一个人开始重新报数,如此循环,直到剩下最后一个人。
需要实现一个算法解决以下问题:(1)给定n和m,求出最后剩下的人的编号。
(2)给定n和m,按顺序输出出圈的人的编号。
⑵算法思路本实验将使用环形链表作为数据结构存储人员编号。
首先,创建一个含有n个节点的环形链表,每个节点表示一个人的编号。
然后,按照报数规则不断遍历链表,当报数等于m时,删除当前节点,并将游标指向下一个节点。
重复此过程,直到只剩下一个节点。
最后剩下的节点即为问题的解。
⒊算法设计⑴定义数据结构为了实现约瑟夫问题的求解,我们需要设计以下数据结构:(1)Person:表示每个人的节点,包含编号和指向下一个节点的指针。
(2)CircularLinkedList:表示环形链表,包含人员总数,当前游标位置和指向第一个节点的指针。
⑵算法实现(1)创建环形链表根据输入的人员总数n,创建一个含有n个节点的环形链表,每个节点表示一个人。
初始化时,节点的编号为从1到n,指向下一个节点的指针为空。
(2)解决约瑟夫问题通过循环遍历环形链表,按照报数规则逐个删除节点,直到只剩下一个节点为止。
具体步骤如下:①初始化报数计数器count=1,游标指向链表的第一个节点。
②从游标指向的节点开始,依次报数,每报数一次,count加1.③当count等于m时,删除当前节点,并将游标指向下一个节点。
④重复步骤②和③,直到只剩下一个节点。
(3)输出解决结果根据求解约瑟夫问题的要求,输出最后剩下的人的编号或按顺序输出出圈人的编号。
⒋性能分析本算法的时间复杂度为O(nm),其中n表示人员总数,m表示报数的步长。
约瑟夫问题数据结构实验报告
![约瑟夫问题数据结构实验报告](https://img.taocdn.com/s3/m/f68e1157ae1ffc4ffe4733687e21af45b307fea3.png)
约瑟夫问题数据结构实验报告[正文]1.实验目的本实验的目的是分析约瑟夫问题,并设计合适的数据结构解决该问题。
2.实验背景约瑟夫问题,又称为约瑟夫环,是一个经典的数学问题。
问题描述如下:有n个人围成一圈,从第一个人开始报数,数到第m个人时将其杀死,然后从下一个人开始重新报数,数到第m个人又将其杀死,如此循环进行,直到所有人都被杀死为止。
求出最后一个被杀的人在初始序列中的编号。
3.实验设计为了解决约瑟夫问题,我们需要设计合适的数据结构来表示这个过程。
以下为实验所采用的数据结构:3.1 线性表由于约瑟夫问题是围成一圈的,因此我们选择使用循环链表来表示人围成的圈。
每个节点代表一个人,包含一个成员变量用于存储人的编号。
3.2 算法采用如下算法来解决约瑟夫问题:1.创建一个循环链表,将n个人的编号分别存入节点中。
2.初始化一个指针p指向链表的第一个节点。
3.从第一个人开始报数,每报到第m个人,将该节点从链表中删除。
4.如果链表中只剩下一个节点,此时的节点即为最后一个被杀的人,输出其编号。
4.实验步骤4.1 数据结构设计根据实验设计中的描述,我们编写了一个含有循环链表和节点的数据结构。
```cppstruct ListNode {int number;ListNode next;};```4.2 实现约瑟夫问题算法根据实验设计中的算法描述,我们编写了解决约瑟夫问题的函数。
```cppint josephusProblem(int n, int m) {// 创建循环链表// 初始化指针p// 开始报数并删除节点// 返回最后被杀的人的编号}```4.3 测试与分析我们通过输入不同的n和m值,测试了约瑟夫问题的解决函数,并对实验结果进行了分析。
5.实验结果经过测试,我们得到了约瑟夫问题的解。
6.实验总结通过本实验,我们深入了解了约瑟夫问题,并成功设计了合适的数据结构和算法解决了该问题。
附件本文档无附件。
法律名词及注释1.约瑟夫问题:亦称为约瑟夫环问题,是一个数学难题,起源于古代历史记载,已有几个世纪的历史。
约瑟夫环实验报告
![约瑟夫环实验报告](https://img.taocdn.com/s3/m/4f43547f336c1eb91a375d68.png)
实验报告课程名称:数据结构班级:实验成绩:实验名称:顺序表和链表的应用学号:批阅教师签字:实验编号:实验一姓名:实验日期:指导教师:组号:实验时间:一、实验目的(1)掌握线性表的基本操作(插入、删除、查找)以及线性表合并等运算在顺序存储结构、链式存储结构上的实现。
重点掌握链式存储结构实现的各种操作。
(2)掌握线性表的链式存储结构的应用。
二、实验内容与实验步骤(1)实验内容:实现约瑟夫环,约瑟夫环(Joseph)问题的一种描述是:编号为1、2、3……n的n个人按照顺时针方向围坐一圈,每人持有一个密码(正整数)。
一开始任选一个正整数作为报数的上限值m,从第一个人开始按照顺时针的方向自1开始顺序报数,报到m时停止报数。
报m的人出列,将他的密码作为新的m值,从他的顺时针方向上的下一个人开始重新从1报数,如此下去,直至所有人全部出列为止。
设计一个程序求出出列顺序。
(2)抽象数据类型和设计的函数描述,说明解决设想。
首先定义一个链表,用其中的data项存储每个人的编号,用password项存储每个人所持有的密码,并且声明一个指针。
之后使用CreatList_CL函数来创建一个循环链表,在其中的data和password中存入编号和密码,最后使最后一个节点的next指向L,使其能够形成循环队列。
定义了函数Display来显示链表当中的内容,以确定存储的数据没有错误。
定义了函数Delete_L来实现约瑟夫环中依次删除的功能,依次比较,如果某个人所持的密码和m值相等,则删除这个结点,并且输出此时该结点的编号和密码,实现出列的功能。
(3)简短明确地写出实验所采用的存储结构,并加以说明。
该实验我主要采用的是线性表的链式存储结构,首先定义了链表的结构,其中包括data项和password项,分别存储每个人的编号和所持密码,还声明了指向下一个结点的指针,该指针可以连接各个结点,并且将最后一个结点的指针指向第一个结点使之成为一个循环链表。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验线性表姓名:班级:学号:实验时间:一、约瑟夫问题1.问题描述设有编号为1,2,...,n(n>0)的n个人围成一圈,从约定编号k(1≤k≤n)开始报数,报到m的人出圈,然后从他的下一位开始新一轮报数。
如此反复下去,直至所有人出圈。
当任意给定n和m时,设计算法求n个人出圈的次序。
2.数据结构设计采用循环单链表,可建立如下的结构体:struct Node{int data;Node *next;};3.功能划分及算法设计规定的主要功能有创建无头节点的循环单链表、节点的删除与输出。
(1)创建无头节点的循环单链表(尾插法)p=new Node;p->next=p;p->data=1;for(int i=2;i<=n;i++){s=new Node;//新建元素结点s->data=i;//输入新建数据元素值s->next=p->next;//新结点链入表尾p->next=s;p=s;}(2)节点的删除与输出Node *Delete_Print(Node *p,Node *pre)//删除、输出函数{Node *q;cout<<p->data<<" ";//输出需要删除的节点的数值while(p->next!=pre)//p定位到删除点的前驱{p=p->next;//}{q=p->next;// 暂存删除结点位置p->next=q->next;//从链表中摘除删除结点delete q;// 释放删除点return p->next;}}4.运行与测试(1)运行程序,提示输入n,m,k,如图所示:(2)分别输入7、5、1,结果如下:5.调试记录及收获调试过程中经常会遇到与预计的删除节点偏差1-2个节点的情况,主要原因是:(1)链表创建完成后指针P未归位(2)删除节点后指针P任然停留在原节点的前驱(3)循环操作时计数器重置数设置错误通过本次实验掌握并练习了循环单链表的创建与部分操作,进一步加深对单链表的认识,提高了实践操作水平。
6.源程序#include<iostream.h>//cout,cinstruct Node{int data;Node *next;};Node *Delete_Print(Node *p,Node *pre)//删除、输出函数{Node *q;cout<<p->data<<" ";//输出需要删除的节点的数值while(p->next!=pre)//p定位到删除点的前驱{p=p->next;//}{q=p->next;// 暂存删除结点位置p->next=q->next;//从链表中摘除删除结点delete q;// 释放删除点return p->next;}}void main(){Node *p,*s,*pre;int m,n,k;cout<<"请依次输入人数n,密码m,起报人数k"<<endl;cin>>n>>m>>k;//创建循环单链表(尾插法)p=new Node;p->next=p;p->data=1;for(int i=2;i<=n;i++){s=new Node;//新建元素结点s->data=i;//输入新建数据元素值s->next=p->next;//新结点链入表尾p->next=s;p=s;}//初始化p=p->next;i=1;while(i<=k){pre=p;p=p->next ;i++;}//定位起报人int count=2;while(pre!=p){if(count==m){p=Delete_Print(p,p);count=1;//计数器重置} else{count++;pre=p;p=p->next;}}Delete_Print(p,p);//删除并输出最后一个节点}二、有序表合并1.问题描述把两个有序表归为一个有序表2.数据结构设计采用单链表存储两个有序表,合并后的表采用带头结点的单链表存储。
struct Node{int data;//数据域,存放表元素Node* next;//指针域,指向下一个结点};3.算法设计规定的主要功能有创建有序顺序表的函数,实现归并功能的函数、显示表内容的函数。
(1)创建单链表Node* CreateList() {Node* Head;Head = new Node;Head->next = NULL;return Head;}(2)键盘输入有序单链表void CinList(Node *Head) {Node *p = Head,*s;int n;cout << "请输入元素个数:";cin >> n;cout << "请按序输入有序表的元素:" << endl;for (int i = 1; i <= n; i++){s = new Node;//新建元素结点cin >> s->data;//输入新建数据元素值s->next = p->next;//新结点链入表尾p->next = s;p = s;}}(3)实现并归功能void Sort(Node* pa, Node* pb,Node *pc) {//实现并归功能Node* p;while (pa != NULL && pb != NULL) {p = new Node;p->next = pc->next;pc->next = p;pc = p;if (pa->data <= pb->data){pc->data = pa->data;pa = pa->next;}else{pc->data = pb->data;pb = pb->next;}}if (pa == NULL) {while (pb != NULL) {p = new Node;p->next = pc->next;pc->next = p;pc = p;pc->data = pb->data;pb = pb->next;}}else {while (pa != NULL) {p = new Node;p->next = pc->next;pc->next = p;pc = p;pc->data = pa->data;pa = pa->next;}}}(4)输出显示表内容oid ListDisplay(Node *Head) {// 遍历显示链表Node * p;//设置工作指针p = Head->next;//从首元结点开始遍历int i = 1;//元素位序while (p){cout << p->data << "\t";p = p->next;i++;}cout << endl;}4.运行与测试运行程序,多次数据测试,部分结果如下:5.调试记录及收获调试过程中,需要注意生成新结点插入到表尾的操作顺序,否则会出现表内容为空等状况,且编译器无法发现异常,需要手动排查。
通过本次的实验练习,掌握了有序表合并的操作,对于尾插法掌握得更加熟练,对于单链表有了更深的理解6.源程序#include <iostream.h>struct Node{int data;//数据域,存放表元素Node* next;//指针域,指向下一个结点};Node* CreateList() {Node* Head;Head = new Node;Head->next = NULL;return Head;}void CinList(Node *Head) {Node *p = Head,*s;int n;cout << "请输入元素个数:";cin >> n;cout << "请按序输入有序表的元素:" << endl;for (int i = 1; i <= n; i++){s = new Node;//新建元素结点cin >> s->data;//输入新建数据元素值s->next = p->next;//新结点链入表尾p->next = s;p = s;}}void ListDisplay(Node *Head) {// 遍历显示链表Node * p;//设置工作指针p = Head->next;//从首元结点开始遍历int i = 1;//元素位序while (p){cout << p->data << "\t";p = p->next;i++;}cout << endl;}void Sort(Node* pa, Node* pb,Node *pc) {//实现并归功能Node* p;while (pa != NULL && pb != NULL) {p = new Node;p->next = pc->next;pc->next = p;pc = p;if (pa->data <= pb->data){pc->data = pa->data;pa = pa->next;}else{pc->data = pb->data;pb = pb->next;}}if (pa == NULL) {while (pb != NULL) {p = new Node;p->next = pc->next;pc->next = p;pc = p;pc->data = pb->data;pb = pb->next;}}else {while (pa != NULL) {p = new Node;p->next = pc->next;pc->next = p;pc = p;pc->data = pa->data;pa = pa->next;}}}void main(void){Node *LA,*LB,*LC,* pa, * pb, * pc;LA = CreateList();LB = CreateList();cout << "创建表1" << endl; CinList(LA);cout << "创建表2" << endl; CinList(LB);pa = LA->next; pb = LB->next;LC= CreateList();cout << "表1的内容是:"; ListDisplay(LA);cout << "表2的内容是:"; ListDisplay(LB);pc = LC;Sort(pa, pb, pc);cout << "合并后的表是:"; ListDisplay(LC); }。