数据结构实验二-
数据结构表达式求值实验报告
竭诚为您提供优质文档/双击可除数据结构表达式求值实验报告篇一:数据结构实验二——算术表达式求值实验报告《数据结构与数据库》实验报告实验题目算术表达式求值学院:化学与材料科学学院专业班级:09级材料科学与工程系pb0920603姓学邮名:李维谷号:pb09206285箱:指导教师:贾伯琪实验时间:20XX年10月10日一、需要分析问题描述:表达式计算是实现程序设计语言的基本问题之一,它的实现是栈的应用的一个典型例子。
设计一个程序,演示通过将数学表达式字符串转化为后缀表达式,并通过后缀表达式结合栈的应用实现对算术表达式进行四则混合运算。
问题分析:在计算机中,算术表达式由常量、变量、运算符和括号组成。
由于不同的运算符具有不同的优先级,又要考虑括号,因此,算术表达式的求值不可能严格地从左到右进行。
因而在程序设计时,借助栈实现。
设置运算符栈(字符型)和运算数栈(浮点型)辅助分析算符优先关系。
在读入表达式的字符序列的同时完成运算符和运算数的识别处理,然后进行运算数的数值转换在进行四则运算。
在运算之后输出正确运算结果,输入表达式后演示在求值中运算数栈内的栈顶数据变化过程,最后得到运算结果。
算法规定:输入形式:一个(:数据结构表达式求值实验报告)算术表达式,由常量、变量、运算符和括号组成(以字符串形式输入)。
为使实验更完善,允许操作数为实数,操作符为(、)、.(表示小数点)、+、-、*、/、^(表示乘方),用#表示结束。
输出形式:演示表达式运算的中间结果和整个表达式的最终结果,以浮点型输出。
程序功能:对实数内的加减乘除乘方运算能正确的运算出结果,并能正确对错误输入和无定义的运算报错,能连续测试多组数据。
测试数据:正确输入:12*(3.6/3+4^2-1)#输出结果:194.4无定义运算:12*(3.6/(2^2-4)+1)#输出结果:表达式出错,除数为0,无意义错误输入:12+s#输出结果:eRRoR!二、概要设计拟采用两种类型的展分别对操作数和操作符进行操作。
《数据结构》实验报告
苏州科技学院数据结构(C语言版)实验报告专业班级测绘1011学号10201151姓名XX实习地点C1 机房指导教师史守正目录封面 (1)目录 (2)实验一线性表 (3)一、程序设计的基本思想,原理和算法描述 (3)二、源程序及注释(打包上传) (3)三、运行输出结果 (4)四、调试和运行程序过程中产生的问题及采取的措施 (6)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (6)实验二栈和队列 (7)一、程序设计的基本思想,原理和算法描述 (8)二、源程序及注释(打包上传) (8)三、运行输出结果 (8)四、调试和运行程序过程中产生的问题及采取的措施 (10)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (10)实验三树和二叉树 (11)一、程序设计的基本思想,原理和算法描述 (11)二、源程序及注释(打包上传) (12)三、运行输出结果 (12)四、调试和运行程序过程中产生的问题及采取的措施 (12)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (12)实验四图 (13)一、程序设计的基本思想,原理和算法描述 (13)二、源程序及注释(打包上传) (14)三、运行输出结果 (14)四、调试和运行程序过程中产生的问题及采取的措施 (15)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (16)实验五查找 (17)一、程序设计的基本思想,原理和算法描述 (17)二、源程序及注释(打包上传) (18)三、运行输出结果 (18)四、调试和运行程序过程中产生的问题及采取的措施 (19)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (19)实验六排序 (20)一、程序设计的基本思想,原理和算法描述 (20)二、源程序及注释(打包上传) (21)三、运行输出结果 (21)四、调试和运行程序过程中产生的问题及采取的措施 (24)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (24)实验一线性表一、程序设计的基本思想,原理和算法描述:程序的主要分为自定义函数、主函数。
数据结构实验报告(C语言)(强力推荐)
数据结构实验实验内容和目的:掌握几种基本的数据结构:集合、线性结构、树形结构等在求解实际问题中的应用,以及培养书写规范文档的技巧。
学习基本的查找和排序技术。
让我们在实际上机中具有编制相当规模的程序的能力。
养成一种良好的程序设计风格。
实验教材:数据结构题集(C语言版)清华大学出版社2007年实验项目:实验一、栈和循环队列㈠、实验内容:①栈掌握栈的特点(先进后出FILO)及基本操作,如入栈、出栈等,栈的顺序存储结构和链式存储结构,以便在实际问题背景下灵活应用。
本程序采用的是链栈结构,具有初始化一个栈、PUSH、POP、显示所有栈里的元素四个功能。
②循环队列掌握队列的特点(先进先出FIFO)及基本操作,如入队、出队等,学会循环队列的实现,以便在实际问题背景下灵活运用。
本程序具有初始化一个队列、入队、出队、显示队列的所有元素、队列长度五个功能。
㈡、实验代码①栈程序代码:#include <stdio.h>#include <malloc.h>#define Stack_Size 6#define ERROR 0#define OK 1typedef int SElemType;typedef struct SNode{SElemType data;struct SNode *next;}SNode,*LinkStack;int CreatTwo(LinkStack &head,int n){int i;SNode *p;head=(LinkStack)malloc(sizeof(SNode));head->next=NULL;printf("请输入数据(数字):\n");for(i=n;i>0;--i){p=(SNode *)malloc(sizeof(SNode));scanf("%d",&p->data);p->next=head->next;head->next=p;}return 1;}int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误,请重新输入\n");elsebreak;}return sn;}int Push(LinkStack &top,SElemType e){SNode *q;q=(LinkStack)malloc(sizeof(SNode));if(!q){printf("溢出!\n");return(ERROR);}q->data=e;q->next=top->next;top->next=q;return(OK);}int Pop(LinkStack &top,SElemType &e){SNode *q;if(!top->next){printf("error!\n");return(ERROR);}e=top->next->data;q=top->next;top->next=q->next;free(q);return(OK);}void main(){ int e;LinkStack top;printf("1.初始化一个栈;\n2.PUSH;\n3.POP;\n4.显示所有栈里的元素;\n5.结束;\n");while(1){switch(menu_select()){case 1:if(CreatTwo(top,Stack_Size))printf("Success!\n");break; case 2:printf("Push:\n");scanf("%d",&e);if(Push(top,e))printf("Success!\n");break;case 3:if(Pop(top,e))printf("Success!\n");printf("%d\n",e);break;case 4:LinkStack p;printf("所有栈里的元素:\n");p=top;while(p->next){p=p->next;printf("%7d",p->data);}printf("\n");break;case 5:return;}}}运行结果:②循环队列程序代码:#include<stdlib.h>#include<stdio.h>#define OVERFLOW -1#define OK 1#define ERROR 0#define MAXSIZE 100typedef struct{int *elem;//队列存储空间int front;int rear;}SqQueue;//判断选择是否正确int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误,请重新输入\n");elsebreak;}return sn;}//参数(传出)SqQueue &Q,循环队列(空)int InitQueue(SqQueue &Q){Q.elem=(int *)malloc(MAXSIZE*sizeof(int));if(!Q.elem)exit(OVERFLOW);Q.front=Q.rear=-1;for(int i=0;i<MAXSIZE;i++)Q.elem[i]=-1;return OK;}//返回Q的元素个数int QueueLength(SqQueue Q){return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;}//显示队列的元素void Display(SqQueue Q){for(int i=0;i<=QueueLength(Q);i++)if(Q.elem[i]!=-1)printf("%d ",Q.elem[i]);printf("\n");}//入队int EnQueue(SqQueue &Q,int e){Q.rear=(Q.rear+1)%MAXSIZE;if(Q.rear==Q.front)return ERROR;Q.elem[Q.rear]=e;return OK;}//出队int DeQueue(SqQueue &Q,int &e){if(Q.front==Q.rear)return ERROR;e=Q.elem[Q.front+1];Q.elem[Q.front+1]=-1;Q.front=(Q.front+1)%MAXSIZE;return OK;}void main(){SqQueue Q;InitQueue(Q);int elem,e;printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为:\n");Display(Q);printf("1.初始化一个队列;\n2.入队;\n3.出队;\n4.显示队列的所有元素;\n5.队列长度:\n6.结束;\n");while(1){switch(menu_select()){case 1:printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为:\n");Display(Q);fflush(stdin);break;case 2:scanf("%d",&elem);EnQueue(Q,elem);printf("队列为:\n");Display(Q);fflush(stdin);break;case 3:DeQueue(Q,elem);printf("队列为:\n");Display(Q);break;case 4:printf("\n队列的所有元素:\n");Display(Q);break;case 5:printf("%d\n",QueueLength(Q));break;case 6:return;}}}运行结果:实验二、数组㈠、实验内容:数组一般不做插入或删除操作,也就是说,一旦建立了数组,则结构中的数据元素个数和元素之间的关系就不再发生变动。
数据结构实验报告实验总结
数据结构实验报告实验总结本次数据结构实验主要涉及线性表、栈和队列的基本操作以及链表的应用。
通过实验,我对这些数据结构的特点、操作和应用有了更深入的了解。
下面对每一部分实验进行总结。
实验一:线性表的基本操作线性表是一种常见的数据结构,本实验要求实现线性表的基本操作,包括插入、删除、查找、遍历等。
在实验过程中,我对线性表的结构和实现方式有了更清晰的认识,掌握了用数组和链表两种方式实现线性表的方法。
实验二:栈的应用栈是一种后进先出(LIFO)的数据结构,本实验要求利用栈实现简单的括号匹配和后缀表达式计算。
通过实验,我了解到栈可以方便地实现对于括号的匹配和后缀表达式的计算,有效地解决了对应的问题。
实验三:队列的应用队列是一种先进先出(FIFO)的数据结构,本实验要求利用队列实现银行排队和迷宫求解。
通过实验,我对队列的应用有了更加深入的了解,了解到队列可以解决需要按顺序处理的问题,如排队和迷宫求解等。
实验四:链表的应用链表是一种常用的数据结构,本实验要求利用链表实现学生信息管理系统。
通过实验,我对链表的应用有了更深入的了解,了解到链表可以方便地实现对于数据的插入、删除和修改等操作,并且可以动态地调整链表的长度,适应不同的需求。
通过本次实验,我掌握了线性表、栈、队列和链表的基本操作,并了解了它们的特点和应用方式。
同时,通过实际编程的过程,我对于数据结构的实现方式和效果有了更直观的认识,也锻炼了自己的编程能力和解决问题的能力。
在实验过程中,我遇到了一些问题,如程序逻辑错误和内存泄漏等,但通过调试和修改,最终成功解决了这些问题,对自己的能力也有了更多的信心。
通过本次实验,我深刻体会到了理论与实践的结合的重要性,也对于数据结构这门课程有了更加深入的理解。
总之,本次数据结构实验给予了我很多有益的启发和收获,对于数据结构的概念、特点和应用有了更深入的理解。
在以后的学习中,我会继续加强对数据结构的学习和研究,不断提高自己的编程能力和解决问题的能力。
数据结构迷宫问题实验报告
《数据结构与算法设计》迷宫问题实验报告——实验二专业:物联网工程班级:物联网1班学号:********姓名:***一、实验目的本程序是利用非递归的方法求出一条走出迷宫的路径,并将路径输出。
首先由用户输入一组二维数组来组成迷宫,确认后程序自动运行,当迷宫有完整路径可以通过时,以0和1所组成的迷宫形式输出,标记所走过的路径结束程序;当迷宫无路径时,提示输入错误结束程序。
二、实验内容用一个m*m长方阵表示迷宫,0和1分别表示迷宫中的通路和障碍。
设计一个程序对于任意设定的迷宫,求出一条从入口到出口的通路,或得出没有通路的结论。
三、程序设计1、概要设计(1)设定栈的抽象数据类型定义ADT Stack{数据对象:D={ai|ai属于CharSet,i=1、2…n,n>=0}数据关系:R={<ai-1,ai>|ai-1,ai属于D,i=2,3,…n}基本操作:InitStack(&S)操作结果:构造一个空栈Push(&S,e)初始条件:栈已经存在操作结果:将e所指向的数据加入到栈s中Pop(&S,&e)初始条件:栈已经存在操作结果:若栈不为空,用e返回栈顶元素,并删除栈顶元素Getpop(&S,&e)初始条件:栈已经存在操作结果:若栈不为空,用e返回栈顶元StackEmpty(&S)初始条件:栈已经存在操作结果:判断栈是否为空。
若栈为空,返回1,否则返回0Destroy(&S)初始条件:栈已经存在操作结果:销毁栈s}ADT Stack(2)设定迷宫的抽象数据类型定义ADT yanshu{数据对象:D={ai,j|ai,j属于{‘’、‘*’、‘@’、‘#’},0<=i<=M,0<=j<=N}数据关系:R={ROW,COL}ROW={<ai-1,j,ai,j>|ai-1,j,ai,j属于D,i=1,2,…M,j=0,1,…N}COL={<ai,j-1,ai,j>|ai,j-1,ai,j属于D,i=0,1,…M,j=1,2,…N}基本操作:InitMaze(MazeType &maze, int a[][COL], int row, int col){初始条件:二维数组int a[][COL],已经存在,其中第1至第m-1行,每行自第1到第n-1列的元素已经值,并以值0表示障碍,值1表示通路。
数据结构实验二_栈的基本操作
青岛理工大学课程实验报告及实验步骤只要X不为0重复做下列动作将X%R入栈X=X/R只要栈不为空重复做下列动作栈顶出栈输出栈顶元素调试过程及实验结果根据输入的十进制数通过桟的基本操作可以转换成二进制、八进制、十六进制的数。
在上机过程中程序的调用没有太大的问题,按照课本的基本算法就可以将程序正确的运行。
总结程序可以完成基本的功能,可以将十进制数转换为其他进制的数,基本掌握了桟的几种常用的操作;但程序存在缺陷,就是不能持续进行操作,输入了一个十进制数只能进行一次数制转换,程序就会退出,有待改进。
附录#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define stack_init_size 100#define stackincrement 10typedef struct sqstack{int *base;int *top;int stacksize;} sqstack;int StackInit(sqstack *s){s->base=(int *)malloc(stack_init_size *sizeof(int));if(!s->base)return 0;{return 0;}}int conversion(sqstack *s){int n,e=0,flag=0;printf("输入要转化的十进制数:\n");scanf("%d",&n);printf("要转化为多少进制:2进制、8进制、16进制填数字!\n");scanf("%d",&flag);printf("将十进制数%d转化为%d进制是:\n",n,flag);while(n){s->top=s->base;s->stacksize=stack_init_size;return 1;}int Push(sqstack *s,int e){if(s->top-s->base>=s->stacksize){s->base=(int*)realloc(s->base,(s->stacksize+stackincrement)*sizeof(int)); if(!s->base)return 0;s->top=s->base+s->stacksize;s->stacksize+=stackincrement;}*(s->top++)=e;return e;}int Pop(sqstack *s,int e){if(s->top==s->base)return 0;e=*--s->top;return e;}int stackempty(sqstack *s){if(s->top==s->base){return 1;}elsePush(s,n%flag);n=n/flag;}while(!stackempty(s)) {e=Pop(s,e);switch(e){case 10: printf("A");break;case 11: printf("B");break;case 12: printf("C");break;case 13: printf("D");break;case 14: printf("E");break;case 15: printf("F");break;default: printf("%d",e); }}printf("\n");return 0;}int main(){sqstack s;StackInit(&s); conversion(&s);return 0;}。
数据结构实验二
数据结构实验二数据结构实验二:队列与栈的实现一、实验目的本实验旨在通过实现队列和栈数据结构,加深对队列和栈实现原理的理解,并熟练掌握队列和栈的基本操作。
二、实验要求1.使用C/C++语言实现队列的基本操作:初始化队列、入队、出队、判空、判满等。
2.使用C/C++语言实现栈的基本操作:初始化栈、入栈、出栈、判空、判满等。
3.验证队列和栈的实现是否正确。
4.分析队列和栈的时间复杂度,并给出实验结果。
5.撰写实验报告,包括实验目的、实验原理、实验步骤、程序源代码、实验结果和分析、实验总结等内容。
三、实验原理1.队列:队列是一种先进先出(FIF0)的数据结构。
在队列中,数据元素按照进入队列的顺序排列,首元素是最先进入的元素,尾元素是最后进入的元素。
队列的基本操作有:初始化队列、入队、出队、判空、判满等。
2.栈:栈是一种后进先出(LIFO)的数据结构。
在栈中,数据元素按照进入栈的顺序排列,但是只能从栈顶进出,即最后进入的元素最先出栈。
栈的基本操作有:初始化栈、入栈、出栈、判空、判满等。
四、实验步骤1.实现队列的基本操作:1.初始化队列:创建一个空队列,并设置相关指针。
2.入队:将新元素插入到队尾。
3.出队:将队头元素删除,并返回其值。
4.判空:判断队列是否为空。
5.判满:判断队列是否已满。
2.实现栈的基本操作:1.初始化栈:创建一个空栈,并设置相关指针。
2.入栈:将新元素压入栈顶。
3.出栈:将栈顶元素弹出,并返回其值。
4.判空:判断栈是否为空。
5.判满:判断栈是否已满。
3.编写测试代码,验证队列和栈的基本操作是否正确。
4.进行性能测试,分析队列和栈的时间复杂度。
五、实验结果与分析1.队列的时间复杂度:●初始化队列:O(1)●入队:O(1)●出队:O(1)●判空:O(1)●判满:O(1)2.栈的时间复杂度:●初始化栈:O(1)●入栈:O(1)●出栈:O(1)●判空:O(1)●判满:O(1)3.根据实验结果可以看出,队列和栈的基本操作的时间复杂度都是O(1),即常数时间复杂度,具有高效性。
北京理工大学数据结构与算法设计实验二
《数据结构与算法设计》实验报告——实验二学院:自动化学院班级:06111001学号:**********姓名:宝竞宇一、实验目的掌握栈的建立,输入,删除,出栈等基本操作。
应用栈解决实际问题。
二、实验内容实现简单计算器的功能,请按照四则运算加、减、乘、除、幂(^)和括号的优先关系和惯例,编写计算器程序。
要求支持运算符:+、-、*、/、%、()和=:①从键盘输入一个完整的表达式,以回车作为表达式输入结束的标志;②输入表达式中的数值均为大于等于零的整数,如果中间计算过程中出现小数也只取整进行计算。
例如,输入:4+2*5= 输出:14输入:(4+2)*(2-10)= 输出:-48三、程序设计1、概要设计抽象数据类型定义:两个栈结构,分别用来储存数据和计算符号宏定义:函数“成功”,“失败的返回值”在主程序程序中先依次输入各表达式,存入相应各栈,然后,调用“判断函数”来判断计算符的优先次序,然后再利用计算函数来计算,表达式值。
其中还有,取栈顶元素函数,存入栈函数。
2、详细设计数据类型实现:struct t{ char dat[200];int top;}prt;入栈函数:存入数组,栈顶指针上移void pushd(long int a){ prd.dat[prd.top++]=a;}出栈:取出对应值,栈顶指针下移long int popd( ){ return prd.dat[--prd.top];}比较优先级:建立数组,比较返回大于小于号。
计算函数:以字符型输入,运算符号,用switch来分支计算判断,返回计算数值long int operation ( long int x, long int y, char a){ s witch(a){ case '+': return x+y;case '-': return x-y;case '*': return x*y;case '/': if ( y )return x/y;else{ printf("Divide 0.\n");return 0;}case '%': return (long int) fmod(x,y);case '^': if (y>=0 ) return (long int) pow(x,y);else return (0);default: printf("Error No. 3\n");return 0;}}主程序:在主程序内,以字符串的形式输入表达式,然后分别调用函数存入各相应栈,然后用数组判断,比较运算符的优先顺序。
数据结构_迷宫求解_实验报告 北邮
数据结构实验报告实验名称:实验二——利用栈结构实现迷宫求解问题学生姓名:班级:班内序号:学号:日期:2012年11月19日一、实验目的1、进一步掌握指针、模板类、异常处理的使用2、掌握栈的操作的实现方法3、掌握队列的操作的实现方法4、学习使用栈解决实际问题的能力5、学习使用队列解决实际问题的能力二、实验要求:利用栈结构实现迷宫求解问题。
迷宫求解问题如下:心理学家把一只老鼠从一个无顶盖的大盒子的入口赶进迷宫,迷宫中设置很多隔壁,对前进方向形成了多处障碍,心理学家在迷宫的唯一出口放置了一块奶酪,吸引老鼠在迷宫中寻找通路以到达出口,测试算法的迷宫如下图所示。
提示:1、可以使用递归或非递归两种方法实现2、老鼠能够记住已经走过的路,不会反复走重复的路径3、可以自己任意设置迷宫的大小和障碍4、使用“穷举求解”的方法三、程序分析1、存储结构栈存储结构;示意图;2、关键算法分析A、绘制迷宫;伪代码:1、输出迷宫的大小及全部设置为障碍;2、根据键盘的输入绘制迷宫的路线,起始点和终点;void draw()//绘制迷宫障碍{k=getch();switch(int(k)){case 105://上if(by>5){by--;j--;}break;case 107://下if(by<M+4){by++;j++;}break;case 106://左if(bx>2){bx=bx-2;i--;}break;case 108://右if(bx<2*N){bx=bx+2;i++;}break;case 114://'R'路map[i][j]=0;cout<<".";break;case 119://'W'墙map[i][j]=-3;cout<<"■";break;case 115://'S'起点s[0].x=i;//起点入栈s[0].y=j;top=1;map[i][j]=-1;cout<<k;break;case 101://'E'终点map[i][j]=-2;cout<<k;break;}gotoxy(bx,by);}B、路径寻找伪代码;1、向某一方向查找是否有路;2、如有遍历一下栈,看是否已经进栈,一进栈就舍弃,寻求下一个;无就让其进栈。
数据结构实验2——栈和队列实验报告
数据结构实验报告实验名称:实验2——栈和队列1 实验目的通过选择下面五个题目之一进行实现,掌握如下内容:进一步掌握指针、模板类、异常处理的使用掌握栈的操作的实现方法掌握队列的操作的实现方法学习使用栈解决实际问题的能力学习使用队列解决实际问题的能力2 实验内容利用栈结构实现八皇后问题。
八皇后问题19世纪著名的数学家高斯于1850年提出的。
他的问题是:在8*8的棋盘上放置8个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列、同一斜线上。
请设计算法打印所有可能的摆放方法。
提示:1、可以使用递归或非递归两种方法实现2、实现一个关键算法:判断任意两个皇后是否在同一行、同一列和同一斜线上2. 程序分析主程序:#include<iostream>using namespace std;const int StackSize=8; //皇后的个数int num=0;template <class T>class SeqStack //定义顺序栈模板类{public:SeqStack(){top=-1;} //构造函数,初始化空栈void Push(T x); //入栈操作void Pop();//出栈操作void PlaceQueen(int row); //放置皇后bool Judgement();//判断是否符合条件void Print();//输出符合条件的皇后排列bool Empty(){if(top==-1) return true;else return false;}; //判断栈是否为空private:T data[StackSize]; //定义数组int top; //栈顶指针};template <class T>void SeqStack<T>::Push(T x) //入栈操作{if(top>=StackSize-1) throw"上溢";top++;//栈顶指针上移data[top]=x;}template <class T>void SeqStack<T>::Pop()//出栈操作{if(Empty()) throw"下溢";top--;//栈顶指针下移}template <class T>bool SeqStack<T>::Judgement()//判断该位置是否合适{for(int i=0;i<top;i++)if(data[top]==data[i]||(abs(data[top]-data[i]))==(top-i))//判断是否满足任意两个皇后不在同列同一斜线return false;return true;}template <class T>void SeqStack<T>::PlaceQueen(int row) //放置皇后{for (int i=0;i<StackSize;i++){Push(i); //入栈if (Judgement())//判断位置是否合适{if (row<StackSize-1)PlaceQueen(row+1); //如果合适满足条件则放置一个皇后,递归调用else{num++;//不满足条件则到下一行Print();//输出符合条件的皇后}}Pop();//出栈}}template <class T>void SeqStack<T>::Print()//输出皇后函数{cout<<"NO."<<num<<":"<<endl; for(int i=0;i<StackSize;i++){for(int j=0;j<data[i];j++){cout<<"□";}cout<<"■";for(int j=StackSize-1;j>data[i];j--){cout<<"□";}cout<<endl;}cout<<endl;}void main(){SeqStack<int> Queen;Queen.PlaceQueen(0);cout<<"总共有"<<num<<"种摆放方法。
厦门理工学院数据结构实验2
《数据结构》实验报告实验序号:2 实验项目名称:顺序表的实现四、实验结果与数据处理1.设A、B均为用数组实现的List类型的有序顺序表,试设计一个函数Alternate,从A、B读取值,构件数组C,使得C的值也有序。
要求:用不同的方式实现(至少两种),并比较算法的效率。
(1)运行结果:图1:先合并之后再排序图2:合并时排序(2)问题分析:在这一问题中,A顺序表和B顺序表的合并方法可以分为先将这两个顺序表合并后排序或者在输入时就对其进行比较元素大小排序。
这里第一种方法,因为上一次实验学习过了快速排序,所以这一次我采用了另一种方法——希尔排序,希尔排序法是对直接插入排序法的优化,通过设置一个增量,对原始序列进行分组,对每组用直接插入排序法排序再整合,再缩小增量,周而复始直至增量为1,完成排序,因此又叫“缩小增量排序法”。
希尔排序的算法性能在面对大量数据时会高于快速排序,它的平均时间复杂度为n*log2n,整体范围为n^(1.3—2)之间。
第二种方法是我们在输入时就对新顺序表进行排序,在输入A顺序表的时候我们正常接收数据,而在输入B顺序表时,我们通过遍历一次当前顺序表同时结合插入数据函数来将B顺序表输入的数据放到正确的位置上,来使整个顺序表能够有序,整体时间复杂度为n^2左右,可见第一种方法的算法效率会更高一些。
2.顺序表表示和实现线性表的如下:【要求】(1)实现顺序表的插入、删除、按值查找等基本操作;(2)假设构建的是非递增有序顺序表,设计算法实现从该有序顺序表中删除所有其值重复的元素,使得表中所有元素的值均不同。
(3)设有一元素为整数的线性表L=(a1,a2,a3,…,an),存放在一维数组A[N]中,设计一个算法,以表中an作为参考元素,将该表分为左、右两部分,其中左半部分每个元素小于等于an,右半部分每个元素都大于an, an位于分界位置上(要求结果仍存放在A[N]中)。
(4)分析以上算法的时间复杂性。
数据结构课程实验报告
数据结构课程实验报告数据结构课程实验报告引言:数据结构是计算机科学中非常重要的一门课程,它研究了数据的组织、存储和管理方法。
在数据结构课程中,我们学习了各种数据结构的原理和应用,并通过实验来加深对这些概念的理解。
本文将对我在数据结构课程中的实验进行总结和分析。
实验一:线性表的实现与应用在这个实验中,我们学习了线性表这种基本的数据结构,并实现了线性表的顺序存储和链式存储两种方式。
通过实验,我深刻理解了线性表的插入、删除和查找等操作的实现原理,并掌握了如何根据具体应用场景选择合适的存储方式。
实验二:栈和队列的实现与应用栈和队列是两种常见的数据结构,它们分别具有后进先出和先进先出的特点。
在这个实验中,我们通过实现栈和队列的操作,加深了对它们的理解。
同时,我们还学习了如何利用栈和队列解决实际问题,比如迷宫求解和中缀表达式转后缀表达式等。
实验三:树的实现与应用树是一种重要的非线性数据结构,它具有层次结构和递归定义的特点。
在这个实验中,我们学习了二叉树和二叉搜索树的实现和应用。
通过实验,我掌握了二叉树的遍历方法,了解了二叉搜索树的特性,并学会了如何利用二叉搜索树实现排序算法。
实验四:图的实现与应用图是一种复杂的非线性数据结构,它由节点和边组成,用于表示事物之间的关系。
在这个实验中,我们学习了图的邻接矩阵和邻接表两种存储方式,并实现了图的深度优先搜索和广度优先搜索算法。
通过实验,我深入理解了图的遍历方法和最短路径算法,并学会了如何利用图解决实际问题,比如社交网络分析和地图导航等。
实验五:排序算法的实现与比较排序算法是数据结构中非常重要的一部分,它用于将一组无序的数据按照某种规则进行排列。
在这个实验中,我们实现了常见的排序算法,比如冒泡排序、插入排序、选择排序和快速排序等,并通过实验比较了它们的性能差异。
通过实验,我深入理解了排序算法的原理和实现细节,并了解了如何根据具体情况选择合适的排序算法。
结论:通过这些实验,我对数据结构的原理和应用有了更深入的理解。
国家开放大学《数据结构》课程实验报告(实验2——线性表)参考答案
//在链表中删除最高分和最低分结点
for(q=head,p=head->next;p!=NULL;q=p,p=p->next)
{
if(p==pmin) { q->next=p->next; p=q; } //删除最低分结点
};
typedef struct pw PW;
//定义链表结点
struct node
{
PW data;
struct node * next;
};
typedef struct node NODE;
NODE *create(int n); //建立单链表
void input(NODE *s,int i); //输入第i个评委信息
(5)遍历链表,累加求和,计算总分及平均分,并输出相关信息。
完整程序
//实验1.1线性表的链接存储结构
#include
#include
#include
#define PWRS 5 //定义评委人数
//定义评委信息
struct pw
{
char name[8]; //姓名
short age; //年龄
float score; //评分
NODE *create(int n)
{
NODE *head,*p,*q;
inti;
p=(NODE*)malloc(sizeof(NODE));
head=p; q=p; p->next=NULL;
for(i=1; i<=n; i++)
{
p=(NODE*)malloc(sizeof(NODE));
使用数据结构基础第五版王中华课后实验
使用数据结构基础第五版王中华课后实验
本次实验是基于《数据结构基础》第五版王中华教授所编写的课本,实验内容包含了
课后习题的部分,并且结合课本中的数据结构实现,加以实践与验证。
实验一:线性表的基本操作
1、目的:加深对线性表基本概念的理解与掌握。
掌握线性表的初始化,清空,判空,获取长度等基本操作。
2、实验步骤:
(1)根据课本提供的线性表结构体定义,编写相应的初始化函数。
(2)编写线性表的清空、判空、获取长度等基本操作函数。
(3)测试以上函数是否正确。
3、实验结果:
测试函数结果均正确。
加深了对线性表基本操作的理解。
实验二:顺序表的插入与删除
1、目的:了解顺序表的插入和删除的实现过程,掌握插入和删除的操作方式和效
果。
(2)实现顺序表的插入(在指定位置插入)和删除(删除指定位置元素)操作。
测试函数结果正确。
了解了单链表和双链表的实现过程,掌握了链表的插入和删除操
作方法。
1、目的:了解栈的基本概念和操作方法,掌握栈的初始化、入栈、出栈、获取栈顶
元素、栈空及栈长等基本操作方法。
(2)实现队列的初始化、入队、出队、获取队头元素、队空及队长等基本操作方法。
总结:通过对《数据结构基础》第五版王中华教授所编写的课本进行实验,加深了对
线性表、顺序表、链表、栈和队列的理解,掌握了这些数据结构的基本操作方法和实现原理。
本次实验让我更有信心在数据结构的学习与实践中取得更好的结果。
数据结构 实验二:单链表的基本操作
数据结构实验二:单链表的基本操作数据结构实验二:单链表的基本操作实验二:单链表的基本操作一、【实验目的】1、理解和掌握单链表的类型定义方法和结点生成方法。
2、掌握建立单链表和显示单链表元素的算法。
3、掌握单链表的查找、插入和删除算法二、【实验内容】1、建立一个整形数的单链表,手动输入10个数,并从屏幕显示单链表元素列表。
2、从键盘输入一个数,查找在以上创建的单链表中是否存在该数;如果存在,显示它的位置;如果不存在,给出相应提示。
3、删除上述单链表中指定位置的元素。
以下就是程序部分代码,恳请调试并补足并使之恰当运转:1.linlist.htypedefstructnode{datatypedata;structnode*next;}slnode;voidlistinitiate(slnode**head)/*初始化*/{/*如果有内存空间,申请头结点空间并使头指针head指向头结点*/if((*head=(slnode*)malloc(sizeof(slnode)))==null)exit(1);(*head)->next=null;/*置链尾标记null*/}intlistlength(slnode*head){slnode*p=head;/*p指向首元结点*/intsize=0;/*size初始为0*/while(p->next!=null)/*循环计数*/{p=p->next;size++;}returnsize;}intlistinsert(slnode*head,inti,datatypex)/*在带头结点的单链表head的数据元素ai(0≤i≤size)结点前*//*填入一个存放数据元素x的结点*/{slnode*p,*q;intj;p=head;/*p指向首元结点*/j=-1;/*j起始为-1*/while(p->next!=null&&j<i-1)/*最终让指针p指向数据元素ai-1结点*/{p=p->next;j++;}if(j!=i-1){printf(\填入边线参数弄错!\return0;}/*生成新结点由指针q指示*/if((q=(slnode*)malloc(sizeof(slnode)))==null)exit(1);q->data=x;q->next=p->next;/*给指针q->next赋值*/p->next=q;/*给指针p->next重新赋值*/return1;}intlistdelete(slnode*head,inti,datatype*x)/*删除带头结点的单链表head的数据元素ai(0≤i≤size-1)结点*//*删除结点的数据元素域值由x带回。
王中华实用数据结构基础第五版实验参考
王中华实用数据结构基础第五版实验参考
本书实用数据结构基础第五版是一本数据结构方面的教材,包含了常见的数据结构和算法,为了帮助读者更好地理解数据结构的相关内容,本书也配备了相应的实验,以下是本书实验的参考内容:
实验一:线性表和数组
1. 实验目的
了解线性表和数组的相关概念、定义与实现,以及相关的操作和算法,掌握线性表和数组的基本运算,提高编程能力。
2. 实验内容
(1)线性表的实现
a. 手写链表的创建与销毁
b. 手写链表的元素插入、删除和访问
c. 链表的遍历与输出
(2)数组的实现
(3)线性表的排序算法
a. 插入排序
b. 冒泡排序
c. 快速排序
(4)数组的查找算法
a. 线性查找
b. 二分查找
3. 实验要求
(1)熟练使用C/C++等高级编程语言实现线性表和数组的相关操作和算法。
(2)在实验中使用合适的数据结构和算法,进行适当的优化,提高程序的效率和运行速度。
(3)设计合适的测试用例,评估程序的正确性和可靠性,并进行必要的调试。
实验二:栈和队列
(3)栈的应用
a. 括号匹配
b. 表达式求值
c. 进制转换
a. 循环队列
b. 优先队列
c. 广度优先搜索算法
实验三:树和图
掌握树和图的相关概念和算法,了解局部和全局搜索算法,提高编程能力。
c. 二叉树的遍历与输出(前序、中序、后序、层次)
(3)树和图的算法
c. Dijkstra算法
d. Floyd-Warshall算法。
数据结构实验答案
实验一:以单链表表示集合,设计算法建立先后输入的两个集合的差。
说明:已知两个集合A和B,集合A-B中包含所有属于集合A而不属于集合B 的元素。
步骤:1.首先建立A和B的单链表2.然后对集合B中的每个元素x,在A中查找,若存在和x相同的元素,则从该链表中删除。
3.打印A-B,进行验证。
实验二:建立一个二叉树,并进行先序和中序遍历。
(递归和非递归算法)步骤1.补充元素0建立一个满二叉树,存储到一维数组2.利用递归算法建立二叉树,注意零的元素处置3.进行递归、非递归的中序和先序遍历。
打印结果。
实验三:先从键盘输入26个字母生成无序数组,对数组排序后,再从键盘输入一个字符进行折半查找。
实验四:为一个图(maxnode=20)建立一个邻接表、编写深度遍历和广度遍历算法并给出遍历结果。
实验一答案:#include<stdio.h>typedef struct linknode{int data;struct linknode *next;} node;node *creatlist(){node *head,*r,*s;int x;head=(node*)malloc(sizeof(node));r=head;printf("input int and end with \n");scanf("%d",&x);while(x!=0){s=(node*)malloc(sizeof(node));s->data=x;r->next=s;s->next=NULL;r=s;scanf("%d",&x);}r->next=NULL;s=head;head=head->next;free(s);return(head);}void subs(){node *p,*p1,*p2,*q,*heada,*headb;heada=creatlist();headb=creatlist();p=heada;p1=p;while(p!=NULL){q=headb;while(q->data!=p->data && q!=NULL) q=q->next; if(q!=NULL){if(p==heada){heada=heada->next;p1=heada;}else if(p->next==NULL) p1->next=NULL;else p1->next=p->next;p2=p->next;p->next=NULL;free(p);p=p2;}else{p1=p;p=p->next;}}p=heada;if(p==NULL)printf("kong\n");elseprintf(" A - B \n");while(p!=NULL){printf("%d\n",p->data);p=p->next;}}main(){subs();}实验二答案://程序目的建立二叉树,同时对他进行先序排列。
数据结构实验二 线性表
数据结构实验二线性表数据结构实验二线性表1. 实验目的1.1 理解线性表的概念和特性1.2 学习线性表的顺序存储结构和链式存储结构1.3 掌握线性表的基本操作:初始化、插入、删除、查找、修改、遍历等1.4 熟悉线性表的应用场景2. 实验内容2.1 线性表的顺序存储结构实现2.1.1 定义线性表结构体2.1.2 初始化线性表2.1.3 插入元素2.1.4 删除元素2.1.5 查找元素2.1.6 修改元素2.1.7 遍历线性表2.2 线性表的链式存储结构实现2.2.1 定义链表节点结构体2.2.2 初始化链表2.2.3 插入元素2.2.4 删除元素2.2.5 查找元素2.2.6 修改元素2.2.7 遍历链表3. 实验步骤3.1 实现顺序存储结构的线性表3.2 实现链式存储结构的线性表3.3 编写测试程序,验证线性表的各种操作是否正确3.4 进行性能测试,比较两种存储结构的效率差异4. 实验结果与分析4.1 执行测试程序,检查线性表的操作结果是否正确4.2 对比顺序存储结构和链式存储结构的性能差异4.3 分析线性表的应用场景,总结线性表的优缺点5. 实验总结5.1 总结线性表的定义和基本操作5.2 回顾实验中遇到的问题和解决方法5.3 提出对线性表实现的改进方向和思考附件:请参考附件中的源代码和实验报告模板。
法律名词及注释:1. 版权:指对某一作品享有的法律上的权利,包括复制权、发行权、改编权等。
2. 法律责任:指违反法律或合同规定所承担的责任。
3. 保密义务:指个人或组织根据法律、法规、合同等规定需要承担的保密责任。
4.知识产权:指人们在社会实践中所创造的智力劳动成果所享有的权利,包括专利权、著作权、商标权等。
数据结构实验报告(二)栈的应用
数据结构实验报告(⼆)栈的应⽤实验说明数据结构实验⼆ 栈的实验——栈的简单应⽤⼀、实验⽬的通过本实验使学⽣了解栈的简单应⽤,熟悉栈的特性及栈在顺序存储上的操作特点,深刻理解栈的基本操作与⽤栈解决应⽤问题的关系;特别训练学⽣使⽤栈解决实际问题的能⼒,为今后⽤栈解决相关问题奠定基础。
⼆、实验内容1.编程实现对给定的⼀组括号序列判断其是否匹配正确。
要求:(1)它必须成对出现,如“(”“)”是⼀对,“[”与“]”是⼀对;(2)出现时有严格的左右关系;(3)可以以嵌套的⽅式同时出现多组多括号,但必须是包含式嵌套,不允许交叉式嵌套。
⽐如“( )”、“[([][])]”这样是正确的,“[(])”或“([()))”或 “(()]”是不正确的。
(4)将处理的括号扩展为针对“()”“[]”“{}”三类。
2.编程实现⼀个简单的⾏编辑功能:⽤户可以输⼊⼀⾏内容,并可进⾏简易编辑。
要求:(1)遇到输⼊部分内容有误时操作退格符“#”表⽰前⼀位⽆效;(2)“@”表⽰之前的内容均⽆效。
实验报告1.实现功能描述编程实现对给定的⼀组括号序列判断其是否匹配正确,将处理的括号扩展为针对“()”“[]”“{}”三类,遇到输⼊部分内容有误时操作退格符“#”表⽰前⼀位⽆效;“@”表⽰之前的内容均⽆效。
2.⽅案⽐较与选择(1)可以使⽤栈和队列来实现。
因为栈的功能⾜以完成题⽬要求,所以初步打算使⽤栈来实现。
(2)因为编写⼀个标准的栈⽐较繁琐,⽽且本题中也没有⽤到所有栈的标准操作,所以通过模拟栈来完成本题。
(3)可以使⽤数组或链表来模拟栈。
因为括号匹配只有3对,所需空间不是很⼤,⼜因为特殊操作#、@可以在数组中通过-1和赋0值实现,因此选择了数组法来模拟栈。
3.设计算法描述(1)定义3个变量,分别⽤于记录()、[]、{}的出现次数。
遇到左符号时变量++,遇到右符号时--,变量为0时表⽰空栈。
当读到#时,再往前读⼀个字符,如果是()、[]、{}中的⼀种,则对其进⾏反向运算,即遇到右符号时++,遇到左符号时--。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实 验 报 告一、实验目的1) 加深对图的表示法和图的基本操作的理解,并可初步使用及操作; 2) 掌握用图对实际问题进行抽象的方法,可以解决基本的问题;3) 掌握利用邻接表求解非负权值、单源最短路径的方法,即利用Dijkstra 算法求最短路径,同时掌握邻接表的建立以及使用方法,能够解决相关的问题;4) 学会使用STL 中的map 抽象实际问题,掌握map ,List,,priority_queue 等的应用。
二、实验内容与实验步骤(1) 实验内容:使用图这种抽象的数据结构存储模拟的欧洲铁路路线图,通过Dijkstra 算法求出欧洲旅行最少花费的路线。
该实验应用Dijkstra 算法求得任意两个城市之间的最少路费,并给出路费最少的路径的长度和所经过的城市名。
(2) 抽象数据类型及设计函数描述1) 抽象数据类型class City :维护一个城市的信息,包括城市名name ,是否被访问过的标记visted ,从某个城市到达该城市所需的总费用total_fee 和总路径长度total_distance ,求得最短路径后路径中到达该城市的城市名from_city 。
class RailSystem :用邻接表模拟欧洲铁路系统,该邻接表使用数据结构map 实现,map 的key-value课程名称:数据结构 班级: 实验成绩: 实验名称:欧洲旅行 学号: 批阅教师签字:实验编号:实验二 姓名: 实验日期:2013 年6 月 18 日 指导教师: 组号:实验时间:值对的数据类型分别为string和list<*Service>,对应出发城市名和该城市与它能够到达的城市之间的Service链表。
class Service:为铁路系统模拟了两个城市之间的直接路线,包括两个城市之间直接到达的费用fee,两城市之间的直接距离distance。
部分设计函数描述●RailSystem(const string& filename)构造函数,调用load_services(string const &filename)函数读取数据●load_services(string const &filename)读取传入的文件中的数据并建立上述两个map以模拟欧洲铁路路线图●reset(void)遍历cities图,初始化所有城市的信息:visted未访问,total_distance最大值,total_fee费用最大值,from_city为空●~RailSystem(void)析构函数,用delete将两个map中所有使用new操作符开辟的空间删除●void output_cheapest_route(const string& from, const string&to, ostream& out);输出两城市间的最少费用的路径,调用calc_route(string from, string to)函数计算最少费用●calc_route(string from, string to)使用Dijkstra算法计算from和to两个城市间的最少费用的路径(3)采用的存储结构1)map<string, list<Service*> > outgoing_services用来保存由一个城市出发可以直接到达的城市名及这两个城市之间的路径信息。
2)list<Service*>以service为指针的list表,保存两城市间的路径。
3)map<string, City*> cities用来保存所有城市信息,通过城市名查找该城市有关信息。
4)priority_queue<City*, vector<City*>, Cheapest> candidates存储候选的遍历城市,City*是优先队列存储的对象类型,vector<City*>是该对象的向量集合,Cheapest是比较规则。
三、实验环境操作系统:Windows 8调试软件:Microsoft visual studio 2012上机地点:综合楼311机器台号:笔记本四、实验过程与分析(1)主要算法该实验主要用到了Dijkstra算法,这个算法要求所有边的权值非负,提出了按路径长度递增的顺序逐步产生最短路径的算法,首先求出长度最短的一条路径,然后参照它求出长度次短的一条路径,以此类推,指导顶点到其他顶点的最短路径全部求完为止即可解决该实验的问题。
1)calc_route(string from, string to)函数利用优先权队列和Dijkstra算法,计算任意两城市之间费用最少的路径,优先权队列按照费用由大到小的顺序入队。
首先初始化所有城市的信息。
通过迭代器遍历它的邻接链表,得到邻接城市名,当这个城市未被被访问过且从弹出的城市到该城市的费用大于这两个邻接城市间费用和出发城市目前的最少费用之和,更新从出发城市到该城市的费用,并且记录这个城市的经由城市为弹出的城市名并将这个城市入栈,同时更新目前的路径长度。
代码如下:reset();//初始化所有城市信息cities[from]->total_fee = 0;cities[from]->total_distance = 0;candidates.push(cities[from]); //将出发城市入队while(!candidates.empty()){string from_city = candidates.top()->name; //获得出发城市名以便在后面得到它直接到达的城市名candidates.top()->visited = true;candidates.pop();list<Service*>::iterator siter = outgoing_services[from_city].begin();//在outgoing_services中找到from对应的城市并取得from对应的list的迭代器while(siter != outgoing_services[from_city].end()){string dest = (*siter)->destination; //得到链表中的出发城市可以直接到达的城市if((cities[dest]->visited == false)&&((*siter)->fee +cities[from_city]->total_fee < cities[dest]->total_fee)){cities[dest]->total_fee = (*siter)->fee +cities[from_city]->total_fee;cities[dest]->total_distance = (*siter)->distance +cities[from_city]->total_distance;cities[dest]->from_city = from_city;candidates.push(cities[dest]); //将与from邻接的destination入队当循环结束时就是当前链表中费用最小的城市}siter ++;}}该算法的时间复杂度为O(N2),在该算法中使用了优先队列对其进行了优化,优先队列的插入与删除的时间都是错误!未找到引用源。
,在使得整个算法在实际的运行时间上有了明显的缩小。
2)load_services(string)函数读入from和to城市后,首先判断这两个城市在cities这个map中是否存在,若不存在则添加到map中。
判断过程需要遍历整个map,这里利用了map的find()函数,减少了空间和时间的使用。
代码如下:if(cities.find (from) == cities.end()){//from不在cities中将其插入City *cfrom = new City(from);cities.insert(pair<string,City*>(from,cfrom));}此外,需要判断outgoing_services中是否有from这个城市,若没有将它添加到outgoing_services中。
添加时先创建一个service保存from城市到to城市的信息。
代码如下:Service *service = new Service(to,fee,distance);if(outgoing_services.find(from) == outgoing_services.end()){//from不在outgoing_services中则to也不在list中将它们插入outgoing_services list<Service*> *l = new list<Service*>();outgoing_services.insert(pair<string,list<Service*>>(from,*l));}outgoing_services[from].push_back(service);3)recover_route(const string& city)函数利用栈的先进先出特性,将求得的路径所经由的城市名入栈再弹栈,则得到正序的路径。
主要代码如下:stack<string> path; //定义栈string final_path;string c = city;path.push(city); //将目标城市入栈while(cities[c]->from_city != ""){ //目标城市经过的城市不为空时path.push(cities[c]->from_city); //将目标城市经过的城市入栈c = cities[c]->from_city; //得到下一个经过的城市}while(path.size()!=1){ //避免多输入一个to 判断到栈的大小为时停止final_path+= (path.top() + " to "); //输出各个经过的城市名path.pop(); //将栈内的城市名弹栈更新top指向的值}final_path += path.top(); //连接最后一个城市即出发城市path.pop(); //将出发城市弹栈return final_path;(2)调试过程中发现的问题及改进方法问题:当向outgoing_services中插入list<Service*>时,插入不止一次,当将处理outgoing_services的代码中插入list的语句移到循环外时,先插入一个空的list,再将数据push进这个list中即可解决该问题。