数据结构实验二报告
数据结构表达式求值实验报告

竭诚为您提供优质文档/双击可除数据结构表达式求值实验报告篇一:数据结构实验二——算术表达式求值实验报告《数据结构与数据库》实验报告实验题目算术表达式求值学院:化学与材料科学学院专业班级: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!二、概要设计拟采用两种类型的展分别对操作数和操作符进行操作。
算法与数据结构实验报告实验二

算法与数据结构实验报告实验二实验名称:线性表实现集合运算姓名:卢丽娟学号:211006289专业:软件工程班级:二班指导教师:陈亦萍日期: 2012年3月24日一、实验目的本实验是要实现线性表的集合运算,通过该实验更深刻地理解线性结构的特点,学会并掌握线性表的顺序或链式表示和实现。
二、实验内容与实验步骤采用线性表表示集合,用线性表实现集合以及基本操作,实现两个集合的并、交、差运算。
用到的各种函数如下程序步骤所示。
步骤:1. 链表销毁void DestoryList_L(list& L){ list p=L->next,s;while(p){ s=p; p=p->next;free(s);}L->next=NULL;}2. 链表初始化void InitList(list &L){ L=NULL;}3. 往链表L中插入元素e,并按升序排列,如果L中已有元素e,则不插入ListInsert_L(list &L, char e){ list p=L->next,t,s; t = L;while(p!=NULL &&p->data<= e){ if(p->data==e) return OK;t=p; p=p->next;}s =(list)malloc(sizeof(LNode));s->data=e;s->next=p;t->next=s;return OK;}4. 创建链表,按字符串输入元素void CreateList_L(list &L, int n){ L =(list)malloc(sizeof(LNode));L->next=NULL;int i=0;for(i=n;i>0;i--){ char e; scanf("%c",&e);ListInsert_L(L,e);}getchar();}5.定义输入函数,分配存储空间void inputdata(list head)//定义输入函数{ list p;char tmp;scanf("%c",&tmp);while(tmp!='\n'){ p=(list)malloc(sizeof(struct LNode));//分配存储空间p->data=tmp;p->next=head->next;head->next=p;scanf("%c",&tmp); }}6.定义输出函数,初始化,并判断其是否为空void outputdata(list head)//定义输出集合函数{ list p;p=head->next;//初始化,p指向第一个结点while(p!=NULL)//判断是否为空{ printf("%c",p->data);p=p->next;} printf("\n");//输出集合函数}7.定义集合的并集函数,其中函数的数据元素均已按值非递减排列void MergeList(list head1,list head2,list head3)//定义集合的并集函数{//已知p1、p2中的数据元素按值非递减排列。
数据结构实验报告实验总结

数据结构实验报告实验总结本次数据结构实验主要涉及线性表、栈和队列的基本操作以及链表的应用。
通过实验,我对这些数据结构的特点、操作和应用有了更深入的了解。
下面对每一部分实验进行总结。
实验一:线性表的基本操作线性表是一种常见的数据结构,本实验要求实现线性表的基本操作,包括插入、删除、查找、遍历等。
在实验过程中,我对线性表的结构和实现方式有了更清晰的认识,掌握了用数组和链表两种方式实现线性表的方法。
实验二:栈的应用栈是一种后进先出(LIFO)的数据结构,本实验要求利用栈实现简单的括号匹配和后缀表达式计算。
通过实验,我了解到栈可以方便地实现对于括号的匹配和后缀表达式的计算,有效地解决了对应的问题。
实验三:队列的应用队列是一种先进先出(FIFO)的数据结构,本实验要求利用队列实现银行排队和迷宫求解。
通过实验,我对队列的应用有了更加深入的了解,了解到队列可以解决需要按顺序处理的问题,如排队和迷宫求解等。
实验四:链表的应用链表是一种常用的数据结构,本实验要求利用链表实现学生信息管理系统。
通过实验,我对链表的应用有了更深入的了解,了解到链表可以方便地实现对于数据的插入、删除和修改等操作,并且可以动态地调整链表的长度,适应不同的需求。
通过本次实验,我掌握了线性表、栈、队列和链表的基本操作,并了解了它们的特点和应用方式。
同时,通过实际编程的过程,我对于数据结构的实现方式和效果有了更直观的认识,也锻炼了自己的编程能力和解决问题的能力。
在实验过程中,我遇到了一些问题,如程序逻辑错误和内存泄漏等,但通过调试和修改,最终成功解决了这些问题,对自己的能力也有了更多的信心。
通过本次实验,我深刻体会到了理论与实践的结合的重要性,也对于数据结构这门课程有了更加深入的理解。
总之,本次数据结构实验给予了我很多有益的启发和收获,对于数据结构的概念、特点和应用有了更深入的理解。
在以后的学习中,我会继续加强对数据结构的学习和研究,不断提高自己的编程能力和解决问题的能力。
数据结构实验报告2篇

数据结构实验报告数据结构实验报告精选2篇(一)实验目的:1. 熟悉数据结构的基本概念和基本操作;2. 掌握线性表、栈、队列、链表等经典数据结构的实现方法;3. 掌握数据结构在实际问题中的应用。
实验内容:本次实验主要包括以下几个部分:1. 线性表的实现方法,包括顺序表和链表,分别使用数组和链表来实现线性表的基本操作;2. 栈的实现方法,包括顺序栈和链式栈,分别使用数组和链表来实现栈的基本操作;3. 队列的实现方法,包括顺序队列和链式队列,分别使用数组和链表来实现队列的基本操作;4. 链表的实现方法,包括单链表、双链表和循环链表,分别使用指针链、双向链和循环链来实现链表的基本操作;5. 综合应用,使用各种数据结构来解决实际问题,例如使用栈来实现括号匹配、使用队列来实现马铃薯游戏等。
实验步骤及结果:1. 线性表的实现方法:a) 顺序表的基本操作:创建表、插入元素、删除元素、查找元素等;b) 链表的基本操作:插入节点、删除节点、查找节点等;c) 比较顺序表和链表的优缺点,分析适用场景。
结果:通过实验,确认了顺序表适用于频繁查找元素的情况,而链表适用于频繁插入和删除节点的情况。
2. 栈的实现方法:a) 顺序栈的基本操作:进栈、出栈、判空、判满等;b) 链式栈的基本操作:进栈、出栈、判空、判满等。
结果:通过实验,掌握了栈的基本操作,并了解了栈的特性和应用场景,例如括号匹配。
3. 队列的实现方法:a) 顺序队列的基本操作:入队、出队、判空、判满等;b) 链式队列的基本操作:入队、出队、判空、判满等。
结果:通过实验,掌握了队列的基本操作,并了解了队列的特性和应用场景,例如马铃薯游戏。
4. 链表的实现方法:a) 单链表的基本操作:插入节点、删除节点、查找节点等;b) 双链表的基本操作:插入节点、删除节点、查找节点等;c) 循环链表的基本操作:插入节点、删除节点、查找节点等。
结果:通过实验,掌握了链表的基本操作,并了解了链表的特性和应用场景。
数据结构实验报告2栈、队列、递归程序设计

日期:学号:姓名:
实验名称:实验报告二栈、队列、递归程序设计
实验目的与要求:
2.1栈和队列的基本操作
(1)正确理解栈的先进后出的操作特点,建立初始栈,通过相关操作显示栈底元素。
(2)程序中要体现出建栈过程和取出栈底元素后恢复栈的入栈过程,按堆栈的操作规则打印结果栈中的元素
{
return(s->top==-1);
}
//---出栈函数
int Pop(SeqStack *&s,ElemType &e)
{
if (s->top==-1)
return 0;
e=s->data[s->top];
s->top--;
return 1;
}
//---初始队列函数
void InitQueue(SqQueue *&q)
q->rear=(q->rear+1)%MaxSize;
q->elem[q->rear]=e;
return 1;
}
//---出队列函数
int OutQueue(SqQueue *&q,ElemType &e)
{
if (q->front==q->rear) //队空
return 0;
q->front=(q->front+1)%MaxSize;
printf("(10)栈为%s,",(StackEmpty(s)?"空":"非空"));
printf("队列为%s\n",(QueueEmpty(q)?"空":"非空"));
数据结构迷宫问题实验报告

《数据结构与算法设计》迷宫问题实验报告——实验二专业:物联网工程班级:物联网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表示通路。
数据结构实验报告

数据结构实验报告一、实验目的数据结构是计算机科学中重要的基础课程,通过本次实验,旨在深入理解和掌握常见数据结构的基本概念、操作方法以及在实际问题中的应用。
具体目的包括:1、熟练掌握线性表(如顺序表、链表)的基本操作,如插入、删除、查找等。
2、理解栈和队列的特性,并能够实现其基本操作。
3、掌握树(二叉树、二叉搜索树)的遍历算法和基本操作。
4、学会使用图的数据结构,并实现图的遍历和相关算法。
二、实验环境本次实验使用的编程环境为具体编程环境名称,编程语言为具体编程语言名称。
三、实验内容及步骤(一)线性表的实现与操作1、顺序表的实现定义顺序表的数据结构,包括数组和表的长度等。
实现顺序表的初始化、插入、删除和查找操作。
2、链表的实现定义链表的节点结构,包含数据域和指针域。
实现链表的创建、插入、删除和查找操作。
(二)栈和队列的实现1、栈的实现使用数组或链表实现栈的数据结构。
实现栈的入栈、出栈和栈顶元素获取操作。
2、队列的实现采用循环队列的方式实现队列的数据结构。
完成队列的入队、出队和队头队尾元素获取操作。
(三)树的实现与遍历1、二叉树的创建以递归或迭代的方式创建二叉树。
2、二叉树的遍历实现前序遍历、中序遍历和后序遍历算法。
3、二叉搜索树的操作实现二叉搜索树的插入、删除和查找操作。
(四)图的实现与遍历1、图的表示使用邻接矩阵或邻接表来表示图的数据结构。
2、图的遍历实现深度优先遍历和广度优先遍历算法。
四、实验结果与分析(一)线性表1、顺序表插入操作在表尾进行时效率较高,在表头或中间位置插入时需要移动大量元素,时间复杂度较高。
删除操作同理,在表尾删除效率高,在表头或中间删除需要移动元素。
2、链表插入和删除操作只需修改指针,时间复杂度较低,但查找操作需要遍历链表,效率相对较低。
(二)栈和队列1、栈栈的特点是先进后出,适用于函数调用、表达式求值等场景。
入栈和出栈操作的时间复杂度均为 O(1)。
2、队列队列的特点是先进先出,常用于排队、任务调度等场景。
数据结构 实验报告

数据结构实验报告一、实验目的数据结构是计算机科学中非常重要的一门课程,通过本次实验,旨在加深对常见数据结构(如链表、栈、队列、树、图等)的理解和应用,提高编程能力和解决实际问题的能力。
二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。
操作系统为 Windows 10。
三、实验内容1、链表的实现与操作创建一个单向链表,并实现插入、删除和遍历节点的功能。
对链表进行排序,如冒泡排序或插入排序。
2、栈和队列的应用用栈实现表达式求值,能够处理加、减、乘、除和括号。
利用队列实现银行排队系统的模拟,包括顾客的到达、服务和离开。
3、二叉树的遍历与操作构建一棵二叉树,并实现前序、中序和后序遍历。
进行二叉树的插入、删除节点操作。
4、图的表示与遍历用邻接矩阵和邻接表两种方式表示图。
实现图的深度优先遍历和广度优先遍历。
四、实验步骤及结果1、链表的实现与操作首先,定义了链表节点的结构体:```cppstruct ListNode {int data;ListNode next;ListNode(int x) : data(x), next(NULL) {}};```插入节点的函数:```cppvoid insertNode(ListNode& head, int val) {ListNode newNode = new ListNode(val);head = newNode;} else {ListNode curr = head;while (curr>next!= NULL) {curr = curr>next;}curr>next = newNode;}}```删除节点的函数:```cppvoid deleteNode(ListNode& head, int val) {if (head == NULL) {return;}ListNode temp = head;head = head>next;delete temp;return;}ListNode curr = head;while (curr>next!= NULL && curr>next>data!= val) {curr = curr>next;}if (curr>next!= NULL) {ListNode temp = curr>next;curr>next = curr>next>next;delete temp;}}```遍历链表的函数:```cppvoid traverseList(ListNode head) {ListNode curr = head;while (curr!= NULL) {std::cout << curr>data <<"";curr = curr>next;}std::cout << std::endl;}```对链表进行冒泡排序的函数:```cppvoid bubbleSortList(ListNode& head) {if (head == NULL || head>next == NULL) {return;}bool swapped;ListNode ptr1;ListNode lptr = NULL;do {swapped = false;ptr1 = head;while (ptr1->next!= lptr) {if (ptr1->data > ptr1->next>data) {int temp = ptr1->data;ptr1->data = ptr1->next>data;ptr1->next>data = temp;swapped = true;}ptr1 = ptr1->next;}lptr = ptr1;} while (swapped);}```测试结果:创建了一个包含 5、3、8、1、4 的链表,经过排序后,输出为 1 3 4 5 8 。
数据结构_迷宫求解_实验报告 北邮

数据结构实验报告实验名称:实验二——利用栈结构实现迷宫求解问题学生姓名:班级:班内序号:学号:日期: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<<"种摆放方法。
数据结构课程实验报告

数据结构课程实验报告数据结构课程实验报告引言:数据结构是计算机科学中非常重要的一门课程,它研究了数据的组织、存储和管理方法。
在数据结构课程中,我们学习了各种数据结构的原理和应用,并通过实验来加深对这些概念的理解。
本文将对我在数据结构课程中的实验进行总结和分析。
实验一:线性表的实现与应用在这个实验中,我们学习了线性表这种基本的数据结构,并实现了线性表的顺序存储和链式存储两种方式。
通过实验,我深刻理解了线性表的插入、删除和查找等操作的实现原理,并掌握了如何根据具体应用场景选择合适的存储方式。
实验二:栈和队列的实现与应用栈和队列是两种常见的数据结构,它们分别具有后进先出和先进先出的特点。
在这个实验中,我们通过实现栈和队列的操作,加深了对它们的理解。
同时,我们还学习了如何利用栈和队列解决实际问题,比如迷宫求解和中缀表达式转后缀表达式等。
实验三:树的实现与应用树是一种重要的非线性数据结构,它具有层次结构和递归定义的特点。
在这个实验中,我们学习了二叉树和二叉搜索树的实现和应用。
通过实验,我掌握了二叉树的遍历方法,了解了二叉搜索树的特性,并学会了如何利用二叉搜索树实现排序算法。
实验四:图的实现与应用图是一种复杂的非线性数据结构,它由节点和边组成,用于表示事物之间的关系。
在这个实验中,我们学习了图的邻接矩阵和邻接表两种存储方式,并实现了图的深度优先搜索和广度优先搜索算法。
通过实验,我深入理解了图的遍历方法和最短路径算法,并学会了如何利用图解决实际问题,比如社交网络分析和地图导航等。
实验五:排序算法的实现与比较排序算法是数据结构中非常重要的一部分,它用于将一组无序的数据按照某种规则进行排列。
在这个实验中,我们实现了常见的排序算法,比如冒泡排序、插入排序、选择排序和快速排序等,并通过实验比较了它们的性能差异。
通过实验,我深入理解了排序算法的原理和实现细节,并了解了如何根据具体情况选择合适的排序算法。
结论:通过这些实验,我对数据结构的原理和应用有了更深入的理解。
南邮数据结构实验报告

南邮数据结构实验报告实验目的,通过本次实验,我们旨在加深对数据结构的理解,掌握数据结构的基本操作和算法设计能力,提高对数据结构的应用能力和实际问题的解决能力。
一、实验内容。
1. 实验一,线性表的基本操作。
本次实验中,我们首先学习了线性表的基本概念和操作,包括插入、删除、查找等操作,并通过实际编程操作来加深对线性表的理解。
2. 实验二,栈和队列的应用。
在实验二中,我们通过实际编程操作来学习栈和队列的应用,包括中缀表达式转换为后缀表达式、栈的应用、队列的应用等内容。
3. 实验三,树和二叉树的基本操作。
实验三中,我们学习了树和二叉树的基本概念和操作,包括树的遍历、二叉树的建立和遍历等内容,并通过实际编程操作来加深对树和二叉树的理解。
4. 实验四,图的基本操作。
最后,我们学习了图的基本概念和操作,包括图的存储结构、图的遍历等内容,并通过实际编程操作来加深对图的理解。
二、实验过程。
在实验过程中,我们首先对实验内容进行了深入的学习和理解,掌握了数据结构的基本概念和操作方法。
然后,我们通过实际编程操作来加深对数据结构的理解,并通过调试和修改程序来提高对数据结构的应用能力和实际问题的解决能力。
在实验过程中,我们遇到了一些问题,但通过不懈的努力和团队合作,最终顺利完成了实验任务。
三、实验结果与分析。
通过本次实验,我们深入理解了数据结构的基本概念和操作方法,掌握了线性表、栈、队列、树、二叉树和图的基本操作,并通过实际编程操作加深了对数据结构的理解。
同时,我们也提高了对数据结构的应用能力和实际问题的解决能力,为今后的学习和工作打下了坚实的基础。
四、实验总结。
通过本次实验,我们不仅加深了对数据结构的理解,还提高了对数据结构的应用能力和实际问题的解决能力。
在今后的学习和工作中,我们将继续努力,不断提升自己的专业能力,为将来的发展打下坚实的基础。
以上就是本次实验的报告内容,谢谢!。
数据结构课程实验报告

数据结构课程实验报告目录1. 实验简介1.1 实验背景1.2 实验目的1.3 实验内容2. 实验方法2.1 数据结构选择2.2 算法设计2.3 程序实现3. 实验结果分析3.1 数据结构性能分析3.2 算法效率比较3.3 实验结论4. 实验总结1. 实验简介1.1 实验背景本实验是数据结构课程的一次实践性操作,旨在帮助学生加深对数据结构的理解和运用。
1.2 实验目的通过本实验,学生将学会如何选择合适的数据结构来解决特定问题,了解数据结构与算法设计的关系并能将其应用到实际问题中。
1.3 实验内容本实验将涉及对一些经典数据结构的使用,如链表、栈、队列等,并结合具体问题进行算法设计和实现。
2. 实验方法2.1 数据结构选择在实验过程中,需要根据具体问题选择合适的数据结构,比如针对需要频繁插入删除操作的情况可选择链表。
2.2 算法设计针对每个问题,需要设计相应的算法来实现功能,要考虑算法的效率和实际应用情况。
2.3 程序实现根据算法设计,编写相应的程序来实现功能,并进行调试测试确保程序能够正确运行。
3. 实验结果分析3.1 数据结构性能分析在实验过程中,可以通过对不同数据结构的使用进行性能分析,如时间复杂度和空间复杂度等,以便选择最优的数据结构。
3.2 算法效率比较实验完成后,可以对不同算法在同一数据结构下的效率进行比较分析,找出最优算法。
3.3 实验结论根据实验结果分析,得出结论并总结经验教训,为后续的数据结构和算法设计提供参考。
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、掌握数据结构的基本操作,如创建、插入、删除、遍历等。
3、提高编程能力和解决实际问题的能力,能够运用合适的数据结构解决具体的问题。
二、实验环境本次实验使用的编程语言为C++,开发环境为Visual Studio 2019。
三、实验内容1、链表的实现与操作单向链表的创建、插入和删除节点。
双向链表的实现和基本操作。
循环链表的特点和应用。
2、栈和队列的实现栈的后进先出特性,实现入栈和出栈操作。
队列的先进先出原则,完成入队和出队功能。
3、树的操作二叉树的创建、遍历(前序、中序、后序)。
二叉搜索树的插入、查找和删除操作。
4、图的表示与遍历邻接矩阵和邻接表表示图。
深度优先搜索和广度优先搜索算法的实现。
四、实验步骤及结果1、链表的实现与操作单向链表:首先,定义了链表节点的结构体,包含数据域和指向下一个节点的指针域。
通过创建链表头节点,并使用循环依次插入新节点,实现了链表的创建。
插入节点时,根据指定位置找到插入点的前一个节点,然后修改指针完成插入操作。
删除节点时,同样找到要删除节点的前一个节点,修改指针完成删除。
实验结果:成功创建、插入和删除了单向链表的节点,并正确输出了链表的内容。
双向链表:双向链表节点结构体增加了指向前一个节点的指针。
创建、插入和删除操作需要同时维护前后两个方向的指针。
实验结果:双向链表的各项操作均正常,能够双向遍历链表。
循环链表:使链表的尾节点指向头节点,形成循环。
在操作时需要特别注意循环的边界条件。
实验结果:成功实现了循环链表的创建和遍历。
2、栈和队列的实现栈:使用数组或链表来实现栈。
入栈操作将元素添加到栈顶,出栈操作取出栈顶元素。
实验结果:能够正确进行入栈和出栈操作,验证了栈的后进先出特性。
《数据结构》实验报告二(样例参考)

《数据结构》实验报告二系别:班级:学号:姓名:日期:指导教师:一、上机实验的问题和要求:单链表的查找、插入与删除。
设计算法,实现线性结构上的单链表的产生以及元素的查找、插入与删除。
具体实现要求:1.从键盘输入10个字符,产生不带表头的单链表,并输入结点值。
2.从键盘输入1个字符,在单链表中查找该结点的位置。
若找到,则显示“找到了”;否则,则显示“找不到”。
3.从键盘输入2个整数,一个表示欲插入的位置i,另一个表示欲插入的数值x,将x插入在对应位置上,输出单链表所有结点值,观察输出结果。
4.从键盘输入1个整数,表示欲删除结点的位置,输出单链表所有结点值,观察输出结果。
5.(★)将单链表中值重复的结点删除,使所得的结果表中各结点值均不相同,输出单链表所有结点值,观察输出结果。
6.(★)删除其中所有数据值为偶数的结点,输出单链表所有结点值,观察输出结果。
7.(★)将单链表分解成两个单链表A和B,使A链表中含有原链表中序号为奇数的元素,而B链表中含有原链表中序号为偶数的元素,且保持原来的相对顺序,分别输出单链表A和单链表B的所有结点值,观察输出结果。
二、程序设计的基本思想,原理和算法描述:(包括程序的结构,数据结构,输入/输出设计,符号名说明等)1.程序结构:定义一个主函数和五个子函数(分别用来实现单链表的创建、查找、插入、删除及单链表的打印)。
2.数据结构:定义一个结构体,作为单链表的结点。
typedef struct stu /*DataType可以是任何相应的数据类型如int, float或char*/ {char Name[Max]; /*定义了数据域,这里存放的是一个字符型数组*/struct stu *next; /*定义了指针域*/}student;3.输入输出设计:创建单链表函数:student *create();输入:通过scanf( )函数及for语句为数据域定义,并定义指针域的指针所指的下一个结点。
数据结构实验2报告总结

一实验目的和要求理解二叉树的基本概念,熟练使用多种表示法构造二叉树,掌握采用二叉链表存储结构实现二叉树的构造、遍历、插入、删除等操作算法;理解线索二叉树的作用,掌握获得线索二叉树节点在指定遍历次序下的前驱或后继结点的方法;理解哈弗曼编码和哈弗曼树的作用,掌握由指定文本求得哈弗曼编码的方法。
理解树的基本概念,熟悉树的多种存储结构,掌握采用孩子兄弟链表存储结构实现树的遍历、插入、删除等操作算法。
通过研究树和二叉树,深刻理解链式存储结构用于表达非线性结构的作用,掌握采用递归算法实现递归数据结构基本操作的设计方法。
二题目及题意分析题目:插入x元素作为p结点的第i个孩子分析:以中国城市作为元素,以插入孩子结点的方式构造一棵树,找到结点p,p不为空时,若p的孩子结点为空,则直接插入x元素作为p的孩子;若p的孩子结点不为空,插入的x元素的位置n小于等于1时,将x元素直接插在最前面;若n大于1时,查找插入的位置执行插入。
三设计方案和功能说明源程序如下:TreeNode.htemplate<class T>class TreeNode //数的孩子兄弟链表结点类{public: //数据域,保存元素T data;TreeNode<T>* child,*sibling; //指针域,分别指向孩子兄弟结点TreeNode<T>(T data,TreeNode<T>*child=NULL,TreeNode<T>*sibling=NULL){this->data=data;this->child=child;this->sibling=sibling;}};Tree.h#include<iostream.h>#include"TreeNode.h" //树的孩子兄弟链表节点类template<class T>class Tree //树类{public:TreeNode<T>*root; //指向根结点Tree(); //构造空树bool isEmpty();//判断是否空树TreeNode<T>* insertChild(TreeNode<T>*p,T value); // 插入value作为结点p的孩子TreeNode<T>* insertChild(TreeNode<T>*p,T x,int i);// 插入x元素作为p结点的第i 个孩子friend ostream&operator<<(ostream&out,Tree<T>&tree);//先根次序遍历树并以树的横向凹入表示法输出树void preOrder(TreeNode<T> *p,int i);};template<class T>Tree<T>::Tree() //构造空树{root=NULL;}template<class T>bool Tree<T>::isEmpty()//判断是否空树{return root==NULL;}template<class T>TreeNode<T>* Tree<T>::insertChild(TreeNode<T>*p,T value) //插入value作为结点p的孩子{TreeNode<T>*q=NULL;if(p!=NULL){q=new TreeNode<T> (value);if(p->child==NULL)p->child=q;else{p=p->child;while(p->sibling!=NULL)p=p->sibling;p->sibling=q;}}return q;}template<class T>TreeNode<T>*Tree<T>::insertChild(TreeNode<T>* p,T x,int i)// 插入x元素作为p结点的第i 个孩子{TreeNode<T>*q=NULL;if(p!=NULL){q=new TreeNode<T>(x);if(p->child==NULL)p->child=q;else{{if(i<=1)//带有容错功能{p->child=new TreeNode<T>(x,NULL,p->child);return p->child;}p=p->child;for(int j=1;p->sibling!=NULL&&j<i-1;j++)p=p->sibling;if( p->sibling==NULL)p->sibling=q;elsep->sibling=new TreeNode<T>(x,NULL,p->sibling);}}}return q;}template<class T>void Tree<T>::preOrder(TreeNode<T> *p,int i){if(p!=NULL){for(int j=0;j<i;j++)cout<<"\t";cout<<p->data<<endl;preOrder(p->child,i+1);preOrder(p->sibling,i);}}template<class T>ostream&operator<<(ostream&out,Tree<T> &tree)//先根次序遍历树并以树的横向凹入表示法输出树{tree.preOrder(tree.root,0);return out;}Main.cpp#include "Tree.h"TreeNode<char*>*aa;void make(Tree<char*>&tree){tree.root=new TreeNode<char*>("中国");tree.insertChild(tree.root,"北京");tree.insertChild(tree.root,"上海");TreeNode<char*>*js=tree.insertChild(tree.root,"江苏省");tree.insertChild(js,"南京市");tree.insertChild(js,"苏州市");TreeNode<char*> *zj=tree.insertChild(tree.root,"浙江省");tree.insertChild(zj,"杭州市");tree.insertChild(zj,"宁波市");TreeNode<char*> *sx=tree.insertChild(tree.root,"山西省");tree.insertChild(sx,"太原市");tree.insertChild(sx,"大同市");aa=zj;}int main(){Tree<char*>tree;make(tree);cout<<tree;tree.insertChild(aa,"无锡市",2);cout<<tree;return 0;}四运行结果及分析1插入位置小于等于1(即n<=1)n=-2时n=0时n=1时2插入位置大于1(即n>1)n=2时五实验总结通过实验理解了树及二叉树的存储结构熟悉掌握了孩子兄弟链表的存储结构实现,以及遍历、查找、删除等操作,深刻理解实现链式存储结构表达非线性的树存储结构。
数据结构实验报告及心得体会

数据结构实验报告及心得体会一、实验背景和目的本次实验的目的是通过设计和实现常见的数据结构,来加深对数据结构的理解,并能够熟练运用。
实验中使用的数据结构有栈、队列和链表,通过这些数据结构的设计和应用,能够更好地掌握数据结构的原理和应用。
二、实验过程1. 栈的设计和实现在本次实验中,我设计了一个基于数组的栈,用于存储数据。
首先,我定义了一个栈类,包含栈的容量、栈顶指针和存储数据的数组。
然后,我实现了入栈、出栈和判断栈空、栈满的操作。
在测试阶段,我编写了一些测试用例,验证栈的功能和正确性。
2. 队列的设计和实现在本次实验中,我设计了一个基于链表的队列。
首先,我定义了一个队列类,包含队列的头指针和尾指针。
然后,我实现了入队、出队和判断队列空、队列满的操作。
在测试阶段,我编写了一些测试用例,验证队列的功能和正确性。
3. 链表的设计和实现在本次实验中,我设计了一个能够存储任意数据类型的单链表。
首先,我定义了一个链表类,包含链表的头指针和尾指针。
然后,我实现了插入、删除和查找节点的操作。
在测试阶段,我编写了一些测试用例,验证链表的功能和正确性。
三、实验结果和分析通过本次实验,我成功设计和实现了栈、队列和链表这三种常见的数据结构。
在测试阶段,我对这些数据结构进行了充分的测试,验证了它们的功能和正确性。
在测试过程中,我发现栈和队列在实际应用中具有很大的作用。
例如,在计算表达式的过程中,可以利用栈来实现中缀表达式转后缀表达式的功能;在操作系统中,可以利用队列来实现进程的调度。
此外,在实验过程中,我还进一步加深了对数据结构的理解。
通过设计和实现数据结构,我学会了如何根据问题的需求选择合适的数据结构,并能够运用数据结构解决实际问题。
在实现过程中,我遇到了一些问题,例如链表的插入和删除操作需要考虑前后指针的变化,但通过不断的实践和思考,最终成功解决了这些问题。
同时,我还注意到数据结构的时间复杂度和空间复杂度对算法的性能有着重要的影响,因此在设计数据结构时需要充分考虑这些因素。
数据结构实验报告

数据结构实验报告一、实验目的数据结构是计算机科学中的重要基础课程,通过本次实验,旨在加深对常见数据结构(如数组、链表、栈、队列、树、图等)的理解和运用,提高编程能力和问题解决能力,培养算法设计和分析的思维。
二、实验环境本次实验使用的编程语言为C++,开发环境为Visual Studio 2019。
三、实验内容1、数组与链表的实现与操作分别实现整数数组和整数链表的数据结构。
实现数组和链表的插入、删除、查找操作,并比较它们在不同操作下的时间复杂度。
2、栈与队列的应用用数组实现栈结构,用链表实现队列结构。
模拟栈的入栈、出栈操作和队列的入队、出队操作,解决实际问题,如表达式求值、任务调度等。
3、二叉树的遍历构建二叉树的数据结构。
实现先序遍历、中序遍历和后序遍历三种遍历算法,并输出遍历结果。
4、图的表示与遍历用邻接矩阵和邻接表两种方式表示图。
实现图的深度优先搜索(DFS)和广度优先搜索(BFS)算法,并分析它们的时间复杂度。
四、实验步骤1、数组与链表数组的实现:定义一个固定大小的整数数组,通过索引访问和操作数组元素。
链表的实现:定义链表节点结构体,包含数据和指向下一个节点的指针。
插入操作:对于数组,若插入位置在末尾,直接赋值;若不在末尾,需移动后续元素。
对于链表,找到插入位置的前一个节点,修改指针。
删除操作:数组需移动后续元素,链表修改指针即可。
查找操作:数组通过索引直接访问,链表需逐个节点遍历。
2、栈与队列栈的实现:用数组模拟栈,设置栈顶指针。
队列的实现:用链表模拟队列,设置队头和队尾指针。
入栈和出栈操作:入栈时,若栈未满,将元素放入栈顶,栈顶指针加 1。
出栈时,若栈不为空,取出栈顶元素,栈顶指针减 1。
入队和出队操作:入队时,在队尾添加元素。
出队时,取出队头元素,并更新队头指针。
3、二叉树构建二叉树:采用递归方式创建二叉树节点。
先序遍历:先访问根节点,再递归遍历左子树,最后递归遍历右子树。
中序遍历:先递归遍历左子树,再访问根节点,最后递归遍历右子树。
数据结构实验报告(二)栈的应用

数据结构实验报告(⼆)栈的应⽤实验说明数据结构实验⼆ 栈的实验——栈的简单应⽤⼀、实验⽬的通过本实验使学⽣了解栈的简单应⽤,熟悉栈的特性及栈在顺序存储上的操作特点,深刻理解栈的基本操作与⽤栈解决应⽤问题的关系;特别训练学⽣使⽤栈解决实际问题的能⼒,为今后⽤栈解决相关问题奠定基础。
⼆、实验内容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)。
实验2 栈和队列应用
实验目的
1.会定义顺序栈和链栈的结点类型。
2.掌握栈的插入和删除结点在操作上的特点。
3.熟悉对栈的一些基本操作和具体的函数定义。
4.会定义顺序队列和链队列的结点类型。
实验内容
1.该程序的功能是实现顺序栈的定义和操作。
包括定义的栈结构类型以及对每一种栈操作的具体的函数定义和主函数。
2.利用栈实现应用后缀表示计算表达式的值。
3.回文游戏。
实验清单
1.
#include<stdio.h>
typedef int DataType; //定义DataType SElemType为int型
typedef int SElemType;
#define MAXSIZE 100 //定义栈的结点类型
typedef struct{
SElemType *base;
SElemType *top;
int stacksize;
}SeqStack;
void Init(SeqStack *S) { //初始化顺序栈
S->base=(SElemType*)malloc(MAXSIZE*sizeof (SElemType));
if(S->base==0) printf("存储分配失败。
\n");
else {S->top=S->base;S->stacksize=MAXSIZE;}
}
void Push(SeqStack *S,DataType x){ //入栈
if(S->top-S->base==S->stacksize)
printf("栈满,无法入栈。
\n");
else {*S->top=x; S->top++;}
}
void Pop(SeqStack *S,DataType e){ //将栈顶元素弹出,用e储存if(S->top=S->base) printf("空栈。
\n");
else {--S->top;e=*S->top;}
}
DataType GetTop(SeqStack *S){ //取栈顶元素
if(S->top==S->base) {printf("空栈。
\n"); return 0;}
else { return *(S->top-1);}
}
void Print(SeqStack *S){ //输出栈中元素
if(S->top==S->base) {printf("空栈。
\n");}
else{
while(S->top!=S->base) printf("%4d ",S->top-1);
}
}
void main() //主函数
{ DataType e;
SeqStack *S;
Init(S); //初始化栈S
Push(S,1); //将1入栈
Push(S,2); //将2入栈
Push(S,3); //将3入栈
Push(S,4); //将4出栈
Pop(S,&e); //栈顶元素4出栈
GetTop(S); //取栈顶元素3
Print(S); //输出栈中元素3 2 1
}
2.
#include<iostream>
#include<string.h>
#include<stdlib.h>
using namespace std;
typedef char DataType; //定义DataType为char型
#define MAXSIZE 100
typedef struct //定义栈的结点类型
{
DataType *base;
DataType *top;
int stacksize;
}SqStack;
void InitStack (SqStack &S) //初始化顺序栈
{
S.base=new char[20];
if(!S.base)
exit(1);
S.top=S.base;
S.stacksize=20;
}
DataType EvaluateExpession(SqStack &S,DataType ch[]) {
int m,n,t,e,i=0;
if(S.top-S.base==S.stacksize) exit(1);
while(ch[i]!='\0')
{
if(ch[i]='+'||'-'||'*'||'/')
{
m=*--S.top;
n=*--S.top;
if(ch[i]='+')
t=m+n;
else if(ch[i]=='-')
t=n-m;
else if(ch[i]=='*')
t=n*m;
else if(ch[i]=='/')
t=n/m;
*S.top++=t;
}
else
*S.top++=ch[i];
}
e=*--S.top;
return(e);
}
void main(){
DataType ch[20];
cout<<"please input the string:"<<endl;
cin>>ch;
SqStack S;
InitStack (S);
cout<<EvaluateExpession(S,ch)<<endl;
}
3.
#include<stdio.h>
typedef int DataType; //定义DataType为int型
typedef char SElemType;//定义SElemType为char类型
#define MAXSIZE 100
typedef struct{ //定义栈的结点类型
DataType *base;
DataType *top;
int stacksize;
}SeqStack;
DataType Init(SeqStack *S) { //初始化顺序栈
S->base=(DataType*)malloc(MAXSIZE*sizeof (DataType));
if(S->base==0) printf("存储分配失败。
\n");
else {S->top=S->base;S->stacksize=MAXSIZE;}
return 1;
}
DataType Push(SeqStack *S,SElemType x){ //入栈if(S->top-S->base==S->stacksize)
printf("栈满,无法入栈。
\n");
else {*S->top=x; S->top++;}
return 1;
}
DataType Pop(SeqStack *S,SElemType e){ //将栈顶元素弹出,用e储存if(S->top=S->base) printf("空栈。
\n");
else {--S->top;e=*S->top;}
return 1;
}
void main() //主函数
{
SeqStack *S;
char later[MAXSIZE],former[MAXSIZE]; //定义栈,字符数组
int i,j;
printf("请输入一串字符:");
for(i=0;i<MAXSIZE;i++){ //键盘输入字符串
scanf("%c",&former[i]);
}
for(i=0;i<MAXSIZE;i++){ //去空格
if(former[i]=="\0"){
for(j=i;j<MAXSIZE-1;j++)
former[j]=former[j+1];
}
}
Init(S); //初始化栈
for(i=0;i<MAXSIZE;i++) //字符串进栈
Push(S,former[i]);
for(i=0;i<MAXSIZE;i++) //出栈
Pop(S,later[i]);
if(strcmp(former[MAXSIZE],later[MAXSIZE])==0)
printf("回文");
else printf("不回文");
}
实验总结
本次实验练习的是栈和队列,但这三个程序我都是用栈编的,第一题和第三题编出来还好些,都是固定算法,但第二题就有些迷糊了,对于计算表达式的值有点不清楚。
所以以后我会加强对用栈计算表达式的值的复习,一定要把程序自己一句一句的编出来。