回文序列判断(运用栈以及队列完成)
数据结构回文实验报告

数据结构回文实验报告1. 实验目的本实验旨在通过使用数据结构中的栈和队列的知识,设计并实现一个回文判断程序,以检测给定的字符串是否为回文。
2. 实验原理回文是指正读和反读都相同的字符串。
在本实验中,我们将使用栈和队列来判断给定字符串是否为回文。
具体步骤如下:2.1 将字符串加入栈和队列将给定的字符串依次加入栈和队列中,保持顺序一致。
2.2 从栈和队列中弹出字符从栈和队列中分别弹出字符,并进行比较。
2.3 判断是否为回文如果所有字符都一一相等,那么该字符串就是回文。
否则,不是回文。
3. 实验步骤接下来,我们将按照上述原理,逐步进行回文判断的实验。
3.1 导入所需库由于本实验仅使用了基本的数据结构,无需导入额外的库或模块。
3.2 创建栈和队列首先,我们需要创建栈和队列的数据结构。
栈可以通过使用列表来实现,而队列则可以通过使用双端队列来实现。
# 创建栈stack = []# 创建队列from collections import dequequeue = deque()3.3 输入字符串接下来,我们需要从用户获取一个待判断的字符串。
# 获取待判断的字符串string = input("请输入待判断的字符串:")3.4 将字符串加入栈和队列将输入的字符串依次加入栈和队列中。
# 将字符串加入栈和队列for char in string:stack.append(char)queue.append(char)3.5 从栈和队列中弹出字符并比较从栈和队列中分别弹出字符,并进行比较,直到栈或队列为空。
is_palindrome =Truewhile len(stack) >0and len(queue) >0:stack_char = stack.pop()queue_char = queue.popleft()if stack_char != queue_char:is_palindrome =Falsebreak3.6 输出判断结果根据比较结果,输出判断字符串是否为回文。
栈和队列的应用实验报告

二、选做题:
1、火车车厢调度问题
[问题描述] 假设停在铁路调试站入口处车厢序列的编号依次为:1,2,3,…,n。设计一个程序,求出所有可能由此输出的长度为n的车厢序列。
姓名
学号
专业年级
单元
第3章
内容
栈和队列的应用
日期
实验题目
实验目的
本次实习的目的在于深入了解栈和队列的特征,以便在实际问题背景下灵活运用它们;同时还将巩固这两种结构的构造方法,接触较复杂问题的递归算法设计。
实验内容
一、必做题(选做两题):
1、称正读和反读都相同的字符序列为“回文”,例如,abcddcba、qwerewq是回文,ashgash不是回文。试写一个算法,判断读入的一个以“@”为结束符的字符序列是否为回文。
四、写出算法设计、编程和调试运行的体会。
数据结构实验报告
一、抄写自己所选择的题目。
二、写出算法设计思路。
三、编写代码,调试运行,实现题目要求(提示:考虑到插入和删除的位置是否超出范围等可能出现的异常问题)。
四、写出算法设计、编程和调试运行的体会。
[基本要求] 程序对栈的任何存取(即更改,读取和状态判别等操作)必须借助于基本运算进行。
[测试数据] 分别取n=1,2,3和4。
实验要求及讨论
(本次实验的要求是否达到,有何问题,是怎么解决的)
一、抄写自己所选择的题目。
二、写出算法设计思路。
三、编写代码,调试运行,实现题目要求(提示:考虑到插入和删除的位置是否超出范围等可能出现的异常问题)。
2、假设以数组se[m]存放循环队列的元素,同时设变量rear和front分别作为队首、队尾指针,且队首指针指向队首节点前一个位置,写出这样设计的循环队列的入队、出队的算法。
数据结构第三章习题答案解析

第三章习题1.按图3.1(b)所示铁道(两侧铁道均为单向行驶道)进行车厢调度,回答:⑴如进站的车厢序列为123,则可能得到的出站车厢序列是什么?⑵如进站的车厢序列为123456,能否得到435612和135426的出站序列,并说明原因。
(即写出以“S”表示进栈、以“X”表示出栈的栈操作序列)。
2.设队列中有A、B、C、D、E这5个元素,其中队首元素为A。
如果对这个队列重复执行下列4步操作:(1)输出队首元素;(2)把队首元素值插入到队尾;(3)删除队首元素;(4)再次删除队首元素。
直到队列成为空队列为止,得到输出序列:(1)A、C、E、C、C (2) A、C、E(3) A、C、E、C、C、C (4) A、C、E、C3.给出栈的两种存储结构形式名称,在这两种栈的存储结构中如何判别栈空与栈满?4.按照四则运算加、减、乘、除和幂运算(↑)优先关系的惯例,画出对下列算术表达式求值时操作数栈和运算符栈的变化过程:A-B*C/D+E↑F5.试写一个算法,判断依次读入的一个以@为结束符的字母序列,是否为形如‘序列1& 序列2’模式的字符序列。
其中序列1和序列2中都不含字符’&’,且序列2是序列1的逆序列。
例如,‘a+b&b+a’是属该模式的字符序列,而‘1+3&3-1’则不是。
6.假设表达式由单字母变量和双目四则运算算符构成。
试写一个算法,将一个通常书写形式且书写正确的表达式转换为逆波兰式。
7.假设以带头结点的循环链表表示队列,并且只设一个指针指向队尾元素结点(注意不设头指针),试编写相应的队列初始化、入队列和出队列的算法。
8.要求循环队列不损失一个空间全部都能得到利用, 设置一个标志域tag , 以tag为0或1来区分头尾指针相同时的队列状态的空与满,请编写与此结构相应的入队与出队算法。
9.简述以下算法的功能(其中栈和队列的元素类型均为int):(1)void proc_1(Stack S){ int i, n, A[255];n=0;while(!EmptyStack(S)){n++; Pop(&S, &A[n]);}for(i=1; i<=n; i++)Push(&S, A[i]);}(2)void proc_2(Stack S, int e) { Stack T; int d;InitStack(&T);while(!EmptyStack(S)){ Pop(&S, &d);if (d!=e) Push( &T, d);}while(!EmptyStack(T)){ Pop(&T, &d);Push( &S, d);}}(3)void proc_3(Queue *Q){ Stack S; int d;InitStack(&S);while(!EmptyQueue(*Q)){DeleteQueue(Q, &d);Push( &S, d);}while(!EmptyStack(S)){ Pop(&S, &d);EnterQueue(Q,d)}}实习题1.回文判断。
3.数据结构作业答案第3章--第3章栈和队列自测卷答案作业答案

head第3章 栈和队列 自测卷答案 姓名 班级一、填空题(每空1分,共15分)1. 【李春葆】向量、栈和队列都是 线性 结构,可以在向量的 任何 位置插入和删除元素;对于栈只能在 栈顶 插入和删除元素;对于队列只能在 队尾 插入和 队首 删除元素。
2. 栈是一种特殊的线性表,允许插入和删除运算的一端称为 栈顶 。
不允许插入和删除运算的一端称为 栈底 。
3. 队列 是被限定为只能在表的一端进行插入运算,在表的另一端进行删除运算的线性表。
4. 在一个循环队列中,队首指针指向队首元素的 前一个 位置。
(注:不一定,这是一种约定,在殷教材中是队首指针指向队列的首元素位置)5. 在具有n 个单元的循环队列中,队满时共有 n-1 个元素。
6. 向栈中压入元素的操作是先 移动栈顶指针 ,后 存入元素 。
7. 从循环队列中删除一个元素时,其操作是 先 移动队首指针 ,后 取出元素 。
(注:不一定,这是一种约定,在殷教材中是先 取出元素 ,后移动队首指针 )8. 〖00年统考题〗带表头结点的空循环双向链表的长度等于 0 。
解:二、判断正误(判断下列概念的正确性,并作出简要的说明。
)(每小题1分,共10分) ( × )1. 线性表的每个结点只能是一个简单类型,而链表的每个结点可以是一个复杂类型。
错,线性表是逻辑结构概念,可以顺序存储或链式存储,与元素数据类型无关。
( × )2. 在表结构中最常用的是线性表,栈和队列不太常用。
错,不一定吧调用子程序或函数常用,CPU 中也用队列。
( √ )3. 栈是一种对所有插入、删除操作限于在表的一端进行的线性表,是一种后进先出型结构。
(√)4. 对于不同的使用者,一个表结构既可以是栈,也可以是队列,也可以是线性表。
正确,都是线性逻辑结构,栈和队列其实是特殊的线性表,对运算的定义略有不同而已。
(×)5. 栈和链表是两种不同的数据结构。
错,栈是逻辑结构的概念,是特殊殊线性表,而链表是存储结构概念,二者不是同类项。
回文问题

问题描述:编程序判断一个字符列是否是回文。
回文是指一个字符序列以中间字符为基准两边字符完全相同。
要求程序从键盘输入一个字符串,字符串长度小于等于80,用于判断回文的字符串中不包括字符串的结束标记符。
基本要求:(1)要求字符序列个数n可由用户随意确定,且有0<n<81;(2)可连续测试任意多个字符序列,可由用户决定退出测试程序;(3)字符序列由用户从键盘输入。
测试数据:(1)abcdcba(2)abcdefghi算法思想:判断回文函数Palinddrome()的算法思想是:把字符串的字符逐个分别存入队列和堆栈,然后逐个出队列和退栈并比较出队列的数据元素和退栈的数据元素是否相等,若全部相等则该字符序列是回文,否则不是回文。
模块划分:(1)void Palindrome(char str[],int n),判断字符序列是否回文函数。
(2)void EnterStr(char str[],int *n),键盘输入字符序列函数。
(3)void main(void),主函数。
循环调用函数EnterStr()和函数Palindrome(),当用户要求继续判断时则继续循环执行,否则结束。
上述三个函数存放在文件Palindrome.c中。
堆栈和队列分别利用第三章讨论的顺序堆栈和顺序循环队列,其文件分别为SeqStack.h和SeqCQueue.h。
数据结构:使用顺序堆栈和循环队列辅助字符序列的回文判断。
本问题中定义顺序堆栈和顺序循环队列的抽象数据类型DataType为cha类型。
源程序:/*文件SeqStack.h*/typedef struct{DataType stack[MaxStackSize];int top;}SeqStack;void StackInitiate(SeqStack *S) //初始化顺序堆栈S{S->top=0;}int StackNotEmpty(SeqStack S) //判断顺序堆栈S非空否,非空时返回1,否则返回0{if(S.top<=0) return 0;else return 1;}int StackPush(SeqStack *S,DataType x) //把数据元素值x压入顺序堆栈S,入栈成功时返回1,否则返回0{if(S->top>=MaxStackSize){printf("堆栈已满无法插入!\n");return 0;}else{S->stack[S->top]=x;S->top++;return 1;}}int StackPop(SeqStack *S,DataType *d) //弹出顺序堆栈S 的栈顶数据元素值到参数d,出栈成功是返回1,否则返回0{if(S->top<=0){printf("堆栈已空无数据元素出栈!\n");return 0;}else{S->top--;*d=S->stack[S->top];return 1;}}int StackTop(SeqStack S,DataType *d) //取顺序堆栈S的当前栈顶数据元素值到参数d,成功时返回1,否则返回0{if(S.top<=0){printf("堆栈已空!\n");return 0;}else{*d=S.stack[S.top-1];return 1;}}/*SeqCQueue.h*/typedef struct{DataType queue[MaxQueueSize];int rear; //队尾指针int front; //队头指针}SeqCQueue;void QueueInitiate(SeqCQueue *Q) //初始化顺序循环队列Q{Q->rear=0; //定义初始队尾指针下标值Q->front=0; //定义初始队头指针下标值}int QueueNotEmpty(SeqCQueue Q) //判断顺序循环队列Q非空否,非空时返回1,否则返回0{if(Q.front==Q.rear) return 0;else return 1;}int QueueAppend(SeqCQueue *Q,DataType x)//把数据元素值x插入顺序循环队列Q的队尾,成功返回1,否则返回0{if((Q->rear+1)%MaxQueueSize==Q->front){printf("队列已满无法插入!\n");return 0;}else{Q->queue[Q->rear]=x;Q->rear=(Q->rear+1)%MaxQueueSize;return 1;}}int QueueDelete(SeqCQueue *Q,DataType *d)//删除顺序循环队列Q的队头元素并赋给d,成功返回1,失败返回0{if(Q->front==Q->rear){printf("循环队列已空无数据元素出队列!\n");return 0;}else{*d=Q->queue[Q->front];Q->front=(Q->front+1)%MaxQueueSize;return 1;}}int QueueGet(SeqCQueue Q,DataType *d) //取循序循环队列Q的当前队头元素并赋给D,成功返回1,失败返回0{if(Q.front==Q.rear){printf("循环队列已空无数据元素可取!\n");return 0;}else{*d=Q.queue[Q.front];return 1;}}/*文件Palindrome.c*/#include<string.h>#include<stdio.h>#define MaxStackSize 80 /*定义堆栈的数据元素最大个数*/#define MaxQueueSize 80 /*定义队列的数据元素最大个数*/typedef char DataType; /*定义具体应用的数据类型DataType*/#include"SeqStack.h"#include"SeqCQueue.h"void Palindrome(char str[],int n){SeqStack myStack;SeqCQueue myQueue;char x,y;int i;StackInitiate(&myStack);QueueInitiate(&myQueue);for(i=0;i<n;i++){QueueAppend(&myQueue,str[i]);StackPush(&myStack,str[i]);}while(QueueNotEmpty(myQueue)==1&&StackNotEmpty(myStack)==1) {QueueDelete(&myQueue,&x);StackPop(&myStack,&y);if(x!=y){printf("不是回文!");return;}}printf("是回文!");}void EnterStr(char str[],int *n){printf("输入字符串(不能超过80个字符):");scanf("%s",str);*n=strlen(str);}void main(void){char ch,str[80];int n;while(1){EnterStr(str,&n);Palindrome(str,n);printf("\n要继续吗?(Y/N):");scanf("%s",&ch);if(ch=='Y'||ch=='y')continue;else return;}}测试情况:。
回文

3.6通常称正读和反读都相同的字符序列为”回文”,例如,abcdeedcba、abcdcba是回文。
若字符序列存储在一个单链表中,编写算法判断此字符序列是否是回文。
思路分析:为了方便编程实现,我们假设字符序列在字符数组中。
先把字符数组中的字符依次进栈和依次进队列,然后循环出栈顶元素、出队头元素,比较二者是否相同,只要有1个不同,就不是回文;如果最后栈、队列有1个不为空,也不是回文;最后栈、队列均空则是回文。
Char str=”abcdedcba”程序流程:定义顺序栈mystack定义顺序队列mysequeue初始化栈初始化队列将字符数组str[]的元素依次入栈将字符数组str[]的元素依次入队列While(栈不空&& 队列不空){出栈顶元素到x;出队头元素到y;If(x!=y)则不是回文,返回}If(栈空&&队列空)则是回文否则不是回文本程序需要使用顺序栈头文件,顺序队列头文件。
下面已经给出,请写出判断是否是回文子程序,再写出测试main函数。
顺序栈头文件内容:#include<stdio.h>typedef struct{DataType data[MaxStackSize];int top;}seqstack;void InitStack(seqstack *s){s->top=-1;}int StackEmpty(seqstack *s){if(s->top==-1)return 1;elsereturn 0;}int SatckPush(seqstack *s,DataType x){if(s->top==MaxStackSize-1){printf("空间已满,无法入栈!\n");return 0;}s->top++;s->data[s->top]=x;return 1;}int StackPop(seqstack *s,DataType *x){if(s->top==-1){printf("堆栈已空,不能完成出栈操作!");return 0;}*x=s->data[s->top];s->top--;return 1;}int GetStackTop(seqstack *s,DataType *x){if(s->top==-1){printf("堆栈已空,不能完成取栈顶元素操作!");return 0;}*x=s->data[s->top];return 1;}顺序队列头文件内容:#include<stdio.h>typedef struct{DataType data[maxsize];int front;int rear;}sequeue;int InitQueue(sequeue *q){q->front=0;q->rear=0;return 1;}int LenQueue(sequeue *q){return (q->rear-q->front+maxsize)%maxsize;}int EmptyQueue(sequeue *q){if(q->front==q->rear)return 1;elsereturn 0;}int InsertQueue(sequeue *q,DataType x){if((q->rear+1)%maxsize==q->front){printf("队列已满,不能完成入队操作!\n");return 0;}q->data[q->rear]=x;q->rear=(q->rear+1)%maxsize;return 1;}int DelQueue(sequeue *q,DataType *x){if(q->front==q->rear){printf("队列已空,不能完成出队操作!\n");return 0;}*x=q->data[q->front];q->front=(q->front+1)%maxsize;return 1;}int GetHead(sequeue *q,DataType *x)5{if(q->front==q->rear){printf("队列已空,不能完成取队头操作!\n");return 0;}*x=q->data[q->front];return 1;}void output(sequeue *q){int i;for(i=q->front;i<q->front+(q->rear-q->front+maxsize)%maxsize;i++) {printf("%d\t",q->data[i%maxsize]);}printf("\n");}。
实验报告——栈和队列的应用

实验报告——栈和队列的应用第一篇:实验报告——栈和队列的应用实验5 栈和队列的应用目的和要求:(1)熟练栈和队列的基本操作;(2)能够利用栈与队列进行简单的应用。
一、题目题目1.利用顺序栈和队列,实现一个栈和一个队列,并利用其判断一个字符串是否是回文。
所谓回文,是指从前向后顺读和从后向前倒读都一样的字符串。
例如,a+b&b+a等等。
题目2.假设在周末舞会上,男士们和女士们进入舞厅时,各自排成一队。
跳舞开始时,依次从男队和女队的队头上各出一人配成舞伴。
若两队初始人数不相同,则较长的那一队中未配对者等待下一轮舞曲。
现要求写一算法模拟上述舞伴配对问题,并实现。
题目3.打印机提供的网络共享打印功能采用了缓冲池技术,队列就是实现这个缓冲技术的数据结构支持。
每台打印机具有一个队列(缓冲池),用户提交打印请求被写入到队列尾,当打印机空闲时,系统读取队列中第一个请求,打印并删除之。
请利用队列的先进先出特性,完成打印机网络共享的先来先服务功能。
题目4.假设以数组Q[m]存放循环队列中的元素, 同时设置一个标志tag,以tag == 0和tag == 1来区别在队头指针(front)和队尾指针(rear)相等时,队列状态为“空”还是“满”。
试编写与此结构相应的插入(enqueue)和删除(dlqueue)算法。
题目5.利用循环链队列求解约瑟夫环问题。
请大家从本组未讨论过的五道题中选择一道,参照清华邓俊辉老师MOOC视频及课本相关知识,编写相应程序。
选择题目3:打印机提供的网络共享打印功能采用了缓冲池技术,队列就是实现这个缓冲技术的数据结构支持。
二、程序清单//Ch3.cpp #include #include #include“ch3.h” template void LinkedQueue::makeEmpty()//makeEmpty//函数的实现{ LinkNode*p;while(front!=NULL)//逐个删除队列中的结点{p=front;front=front->link;delete p;} };template bool LinkedQueue::put_in(T&x){//提交命令函数if(front==NULL){//判断是否为空front=rear=new LinkNode;//如果为空,新结点为对头也为对尾front->data=rear->data=x;if(front==NULL)//分配结点失败return false;} else{rear->link=new LinkNode;//如不为空,在链尾加新的结点rear->link->data=x;if(rear->link==NULL)return false;rear=rear->link;} return true;};template bool LinkedQueue::carry_out()//执行命令函数 { if(IsEmpty()==true)//判断是否为空{return false;} cout<data<LinkNode*p=front;front=front->link;//删除以执行的命令,即对头修改delete p;//释放原结点return true;};void main()//主函数 { LinkedQueue q;//定义类对象char flag='Y';//标志是否输入了命令const int max=30;//一次获取输入命令的最大个数while(flag=='Y')//循环{ int i=0;char str[max];//定义存储屏幕输入的命令的数组gets(str);//获取屏幕输入的命令while(str[i]!=''){q.put_in(str[i]);//调用提交命令函数,将每个命令存入队列中i++;}for(int j=0;j<=i;j++){if(q.IsEmpty()==true)//判断是否为空,为空则说明没有可执行的命令{cout<cin>>flag;continue;//为空跳出for循环为下次输入命令做好准备}q.carry_out();//调用执行命令的函数,将命令打印并删除}三、程序调试过程中所出现的错误无。
数据结构C语言回文判断(运用栈以及队列完成)

数据结构实验报告回文判断班级:学号:学生姓名:指导教师:时间:2015年5月5日1.实验目的:熟悉栈和队列的各项操作,区别栈和队列的操作原理。
2.实验内容:利用栈的操作完成读入的一个以@结尾的字符序列是否是回文序列的判断.回文序列即正读与反读都一样的字符序列;例如:123&321@是;123&4321@、123&312@不是算法思想:从键盘上读取一个字符,同时存储在顺序栈与链队列之中,直到字符序列的最后一个字符为@停止输入,因为要满足特定的要求:序列1&序列2,故设置夜歌标记量falg=1,判断输入的元素个数是否为奇数个,若为偶数个则令flag=0,若为奇数个继续判断栈的中间元素是否为&,若不是则令flag=0,若是,将栈和队列中的元素依次出列,判断是否相等,若不相等则令flag=0,最后将flag的值返回给主函数,若flag被修改为0说明不是回文序列,否则反之!!判断回文序列的流程图:算法实现:(1)void InitStack(SeqStack *s):栈初始化模块,即初始化一个空栈,随后对该空栈进行数据的写入操作;(2)int push(SeqStack *s,char ch):入栈操作,即给空栈中写入数据;(3)int pop(SeqStack *s,char *x):出栈操作,即将栈中的数据输出,由于栈的操作是先进后出,因此,出栈的数据是原先输入数据的逆序;(4)void InitQuene(LinkQ *q):队列初始化,即初始化一个空队列,最后对该空队列进行数据的写入操作;(5)int enter(LinkQ *q,char ch):入队操作,即给空队列中写入数据;(6)int deleteq(LinkQ *q,char *c):出队操作,即将队列中的数据输出,由于队列的操作是先进先出,因此,出队的数据室原先输入数据的正序;(7)int huiwen(SeqStack s,LinkQ q):输入序列并判断所输入的序列是否是回文序列;(8)void main():主函数,用于调用前面的模块,并输出最终的判断结果。
第二单元栈和队列 答案

A.通常不会出现栈满的情况B.通常不会出现栈空的情况
C.插入操作更容易实现D.删除操作更容易实现
15.若一个顺序栈中元素为n个,做进栈运算时发生上溢,则说明该栈的最大容量为(B)。
A. n-1B. n C. n+1 D. n/2
16.允许对队列进行的操作有D。
6.栈的插入和删除只能在栈的栈顶进行,后进栈的元素必定先出栈,所以又把栈称为__LIFO表;队列的插入和删除运算分别在队列的两端进行,先进队列的元素必定先出队列,所以又把队列称为___FIFO__表。
7.设F和R分别表示顺序循环队列的头指针和尾指针,或F指向队头元素的前一个位置,R指向队尾元素则判断该循环队列为空的条件为F==R。
13.对于顺序存储结构的栈,在做入栈运算时应先判断栈是否栈满;在做出栈运算时应先判断栈是否空栈;当栈中元素为n个,做入栈运算时发生上溢,则说明该栈的最大容量为n个元素空间。
三、判断题(每题1分,共12分)
1.队列是一种插入和删除操作分别在表的两端进行的线性表,是一种先进后出的结构。(×)
2.不论是入队列操作还是入栈操作,在顺序存储结构上都需要考虑“溢出”情况。(√)
A.i B.n-i C.n-i+1 D.不确定
7.设计一个判别表达式中左、右括号是否配对出现的算法,采用D数据结构最佳。A.线性表的顺序存储结构B.队列C.线性表的链式存储结构D.栈
8.判定一个顺序栈st(最多元素为MaxSize)为满的条件是D。
A.st->top != -1 B.st->top == -1
Int fact(inrn 1;
Else return n*fact(n-1);
}
数据结构回文序列判断实验报告

数据结构回文序列判断实验报告1.实验目的本实验旨在通过使用数据结构中的栈来判断一个给定的序列是否为回文序列。
2.实验原理回文序列是指正读和反读都相同的序列。
在本实验中,我们使用栈来实现回文序列的判断。
具体原理如下:-将给定的序列逐个字符入栈,直到遇到序列结束符(如空格或结束符号)。
-之后,将栈中的字符逐个出栈,并与序列的对应字符比较。
-如果出栈的字符与序列的对应字符不相同,则该序列不是回文序列;如果全部对应字符相同,则该序列是回文序列。
-需要注意的是,如果序列为奇数个字符,那么中间的字符可以不进行比较。
3.实验步骤本实验的具体步骤如下:1)初始化一个空栈。
2)读入一个字符,并将其入栈,直到遇到序列结束符。
3)读入序列的每一个字符,并将其与栈顶字符进行比较。
4)如果比较结果不相同,则该序列不是回文序列;如果比较结果相同,则继续比较下一个字符。
5)如果栈为空且所有字符都比较完毕,则该序列是回文序列;否则,该序列不是回文序列。
4.实验结果本实验使用了多组样例数据进行测试,以下是部分实验结果:- 输入序列:"aba",输出:是回文序列。
- 输入序列:"abcba",输出:是回文序列。
- 输入序列:"abcca",输出:不是回文序列。
- 输入序列:"abcdcba",输出:是回文序列。
5.实验分析通过对实验结果的分析,可以得出以下结论:-本实验的算法能够正确判断给定序列是否为回文序列。
-由于使用了栈来辅助判断,算法的时间复杂度为O(n),其中n为序列的长度。
6.实验总结本实验通过使用数据结构中的栈,成功判断了一个给定序列是否为回文序列。
通过实验过程,我们深入理解了栈的应用和回文序列的判断原理,并熟悉了实际编程的过程。
同时,我们也认识到了栈在解决一些问题时的便捷性和高效性。
在今后的学习和工作中,我们将更加熟练地运用栈来解决问题。
栈判断回文实验报告

一、实验目的1. 理解栈的基本原理和操作。
2. 掌握使用栈判断字符串是否为回文的算法。
3. 分析算法的效率,并优化算法。
二、实验背景回文是一种特殊的字符串,它从前往后读和从后往前读都是相同的。
例如,“madam”、“racecar”等都是回文。
判断一个字符串是否为回文是一个常见的问题,而使用栈来解决这个问题是一种有效的方法。
三、实验内容1. 设计一个栈类,实现栈的基本操作:初始化、入栈、出栈、判断栈是否为空。
2. 编写一个函数,使用栈来判断一个字符串是否为回文。
3. 分析算法的效率,并进行优化。
四、实验步骤1. 定义栈类```pythonclass Stack:def __init__(self):self.items = []def is_empty(self):return len(self.items) == 0def push(self, item):self.items.append(item)def pop(self):if not self.is_empty():return self.items.pop()return Nonedef peek(self):if not self.is_empty():return self.items[-1]return None```2. 编写判断回文函数```pythondef is_palindrome(s):stack = Stack()for char in s:stack.push(char)result = Truewhile not stack.is_empty():if stack.pop() != s[stack.size() - 1 - stack.index()]:result = Falsebreakreturn result```3. 分析算法效率在这个算法中,我们需要遍历整个字符串一次来入栈,然后再遍历一次出栈。
因此,时间复杂度为O(n),其中n为字符串的长度。
回文问题

目录1.问题描述----------------------------------------------------------------------22.具体要求----------------------------------------------------------------------23.测试数据----------------------------------------------------------------------24.算法思想----------------------------------------------------------------------25.模块划分----------------------------------------------------------------------36.数据结构----------------------------------------------------------------------37.源程序------------------------------------------------------------------------48.测试情况--------------------------------------------------------------------149.设计总结--------------------------------------------------------------------1610.参考文献--------------------------------------------------------------------17课程设计报告1、问题描述找到一个文档中的回文单词并输出。
回文单词就是从左读到右和从右读到左是一样的,如:did、txt、eye等,其中文档中的内容有字母、数字和标点符号,回文单词的判断是不包含标点符号的,但文件输入流读取的时候标点也被一起读取进来了,因此要删除字符串中的标点符号,单独对每个单词进行判断。
回文判断

然后出栈并依次和字符数组比较是否相等,从而判断字符序列是否回文数,代码如下: #include "stdio.h" #include "stdlib.h" #include "string.h" #define EMPTY 0 #define FULL 10000 #define MAX 10000 typedef char data; typedef struct elem { data d; struct elem *next; }elem; typedef struct stack { int cnt; elem *top; }stack; void initialize(stack *stk); void push(data d, stack *stk); data pop(stack *stk); bool empty(const stack *stk); bool full(const stack *stk); //栈操作函数 void initialize(stack *stk) { stk->cnt = 0; stk->top = NULL; } bool empty(const stack *stk) { return stk->cnt == EMPTY; } bool full(const stack *stk) { return stk->cnt == FULL; } void push(data d, stack *stk) { elem *p; if (!full(stk)) { p = (elem *)malloc(sizeof(elem)); p->d = d; p->next = stk->top; stk->top = p; stk->cnt++; } } data pop(stack *stk) { data d; elem *p; if(!empty(stk)) { d = stk->top->d; p = stk->top; stk->top = stk->top->next; stk->cnt--; free(p); } return d; } int main(void) { data input[MAX]; stack temp; int i = 0; int flag = 0; initialize(&temp); //初始化临时栈 scanf("%s", &input); //输入字符串 while (input[i] != '@') {//字符串入栈 push(input[i], &temp); i++; } while (!empty(&temp)) {//字符依次出栈和字符数组比较,判断是否回文数 if (temp.top->d == input[flag]) { pop(&temp); flag++; } else { printf("此字符序列不是回文数!\n"); break; } } if (empty(&temp)) printf("此字符序列是回文数!\n"); return 1; }判断用户输入的字符串是否为回文//**********题目****************////判断用户输入的字符串是否为回文//回文是指顺读和反读都一样的串//例:abccba为回文,abcdab不是回文//*****************************////数据结构:循环队列和顺序栈//算法思想://1.将字符串按照用户输入的顺序分别入栈和队列//2.分别从队列和栈中取出首个字符//3.比较取出的字符,若相等,继续分别从队列和栈中取首个字符;否则跳出循环,并设置标志flag=0;//4.若队列和栈中的字符取完,则结束,设置标志flag=1;//5.flag=1,表示字符从前往后和从后往前的序列完全匹配,该字符串属于回文//6.flag=0,表示字符从前往后和从后往前的序列不完全匹配,该字符串不属于回文//programer:cooler#include <stdio.h>#include<stdlib.h>#define m 100typedef struct{char stack[m];int top;}stackstru; // 定义栈typedef struct {char queue[m];int front;int rear;}queuestru; //定义队列void main(){//函数声明int stinit(stackstru *s); //初始化顺序栈int stempty(stackstru *s); //判断栈是否为空int stpush(stackstru *s,char x); //入栈char stpop(stackstru *s); //出栈int quinit(queuestru *q); //初始化循环队列int quempty(queuestru *q); //判断队列是否为空int enqueue(queuestru *q,char e); //入队char dequeue(queuestru *q); //出队//char c;int flag=0;stackstru *s=(stackstru *)malloc(sizeof(stackstru)); //为顺序栈申请空间queuestru *q=(queuestru *)malloc(sizeof(queuestru)); //为队列申请空间stinit(s); //初始化栈quinit(q); //初始化队列printf("Input a string:\n");//输入字符串,输入@标示输入结束。
栈和队列123

实验报告填写内容时,可把表格扩大。
实验的源程序代码(要有注释)附在表后。
题目一程序代码:#include"stdio.h"#include"malloc.h"#define MAXSIZE 100typedef char elemtype;typedef struct{elemtype data[MAXSIZE];int top;}SeqStack;typedef struct{elemtype data[MAXSIZE];int front,rear;}SeqQueue;SeqStack *InitStack(SeqStack *S){S=(SeqStack *)malloc(sizeof(SeqStack));S->top=-1;return(S);}int Push(SeqStack *S,int item){if(S->top==MAXSIZE-1){printf("Stack overflow\n");return 0;}else{S->data[++S->top]=item;return 1;}}elemtype Pop(SeqStack *S){if(S->top==-1){printf("Stack is empty.\n");return 0;}else{S->top--;return(S->data[S->top+1]);}}SeqQueue *InitQueue(SeqQueue *Q){Q=(SeqQueue *)malloc(sizeof(SeqQueue));Q->front=Q->rear=0;return(Q);}int EnQueue(SeqQueue *Q,elemtype item){if((Q->rear+1)%MAXSIZE==Q->front){printf("Queue overflow");return(0);}else{Q->data[Q->rear]=item;Q->rear=(Q->rear+1)%MAXSIZE;return(1);}}elemtype DeQueue(SeqQueue *Q){elemtype item;if(Q->rear==Q->front){printf("Queue is emtype");return(0);}else{item=Q->data[Q->front];Q->front=(Q->front+1)%MAXSIZE;return(item);}}int huiwen(){elemtype a,b,c;int i=0,n=0,t=1;SeqStack *S;SeqQueue *Q;S=InitStack(S);Q=InitQueue(Q);printf("Please input the item:");scanf("%c",&c);while(c!='@'){EnQueue(Q,c);Push(S,c);scanf("%c",&c);n++;}for(i=0;i<n;i++){a=Pop(S);b=DeQueue(Q);if(a!=b) t=0;}if(t!=0) return(1);else return(0);}main(){int a;printf("Ruanjian Gongcheng XX 3100305210 \n");a=huiwen();if(a==1) printf("Yes");else printf("No");getchar();getchar();}题目一程序代码:#include"stdio.h"#include"malloc.h"#define MAXSIZE 100typedef int elemtype;typedef struct{elemtype data[MAXSIZE];int top;}SeqStack;SeqStack *InitStack(SeqStack *S){S=(SeqStack *)malloc(sizeof(SeqStack));S->top=-1;return(S);}int StackEmpty(SeqStack *S){if(S->top==-1){return 0;}else{return 1;}}int Push(SeqStack *S,int item){if(S->top==MAXSIZE-1){printf("Stack overflow\n");return 0;}else{S->data[++S->top]=item;return 1;}}elemtype Pop(SeqStack *S){if(S->top==-1){printf("Stack is empty.\n");return 0;}else{S->top--;return(S->data[S->top+1]);}}void zhuanhuan(int n,int i){int a,k;SeqStack *S;S=InitStack(S);while(n!=0){a=n%i;Push(S,a);n=n/i;}while(1){k=StackEmpty(S);if(k==0) break;else{a=Pop(S);printf("%d",a);}}}main(){int i,n,t,z;elemtype q;SeqStack *P;P=InitStack(P);printf("Ruanjian Gongcheng XX 3100305210\nPlease input a number:");scanf("%d",&n);printf("Please input another number:");scanf("%d",&i);zhuanhuan(n,i);getchar();getchar();}。
堆栈判断回文实验报告

一、实验目的1. 理解堆栈(栈)的基本概念和操作。
2. 掌握利用堆栈判断字符串是否为回文的方法。
3. 提高编程能力,巩固数据结构知识。
二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发工具:Visual Studio 2019三、实验原理回文是一种正读和反读都相同的字符串。
例如,"madam"、"racecar"等都是回文。
堆栈是一种先进后出的数据结构,利用堆栈可以方便地实现字符串的逆序。
因此,可以通过以下步骤判断一个字符串是否为回文:1. 将字符串的每个字符依次入栈。
2. 将字符串的每个字符依次出栈,并与原字符串进行对比。
3. 如果所有字符都能一一对应,则字符串为回文;否则,不是回文。
四、实验步骤1. 创建一个字符串输入函数,用于从用户处获取字符串。
2. 创建一个堆栈类,包括入栈、出栈、判空、判满等基本操作。
3. 创建一个判断回文的函数,实现上述实验原理。
4. 在主函数中调用输入函数、堆栈类和判断回文函数,输出结果。
五、实验代码```cpp#include <iostream>#include <string>using namespace std;// 堆栈类template <typename T>class Stack {private:T data; // 动态数组int top; // 栈顶指针int maxSize; // 栈的最大容量public:Stack(int size) : maxSize(size), top(-1) { data = new T[maxSize];}~Stack() {delete[] data;}// 入栈操作bool push(T element) {if (top == maxSize - 1) {return false; // 栈满}data[++top] = element;return true;}// 出栈操作bool pop(T &element) {if (top == -1) {return false; // 栈空 }element = data[top--];return true;}// 判空操作bool isEmpty() {return top == -1;}// 判满操作bool isFull() {return top == maxSize - 1; }};// 判断回文函数bool isPalindrome(string str) {Stack<char> stack;int len = str.length();// 将字符串的每个字符入栈for (int i = 0; i < len; i++) {stack.push(str[i]);}// 将字符串的每个字符出栈,并与原字符串进行对比 for (int i = 0; i < len; i++) {char c;if (stack.pop(c)) {if (c != str[i]) {return false; // 字符串不是回文}} else {return false; // 栈空,字符串不是回文 }}return true; // 字符串是回文}int main() {string str;cout << "请输入一个字符串:";getline(cin, str);if (isPalindrome(str)) {cout << "该字符串是回文。
回文

9 / 12
4-2
void push(Stack & s,char str) //入栈 { *s.top=str; ++s.top; } char pop(Stack & s,char &str) //出栈 { str=*--s.top; return str; }
10 / 12
tack s; //创建一个对象 ChuStack(s); //通过一个函数来初始化一个栈 SqQueue *q; // 创建一个列队的对象 InitQueue(q); //初始化一个列队 char a[CHARSIZE],str;//定义一个字符数组 int k,m,num=0; / /定义几个int型变量 cout<<"请输入一串字符串!"<<endl; cin>>a; k=strlen(a); //确定输入的字符的长度
22 / 12
实验结果
23 / 12
总结
通过此次任务,首先学会了队列和 栈的定义及其相关操作,其次了解栈和队 列区别,在次通过此次任务也加深了对上 次任务中的栈的理解,最后就是提升了自 我的编程能力与理解能力,在编程过程中 会遇到许多问题比如一开始所输入的字符 串中要用字符'#'来作为字符输入结束的标 志,最后查阅相关资料后解决了此问题。 总之,用数组的方法最简单,栈次之, 但是无论用哪种方法,其解题思路是不变 的。
03
3.1 3.2
对列
队列:另一种限定存取位置的线性表 特点:先进先出(First In/ Firs Out)),只用允许在表的一端插入,在另一端删除 对头(front):允许删除的一端
队尾(rear):允许插入的一端;
实验报告(栈和队列)

附录A实验报告课程:数据结构(c语言)实验名称:栈和队列系别:数字媒体技术实验日期: 11月15号专业班级:组别:姓名:学号:实验报告内容验证性实验一、预习准备:实验目的:1. 掌握栈的顺序表示、链表表示以及相应操作的实现。
特别注意栈空和栈满的条件;2. 掌握队列的顺序表示、链表表示以及相应操作的实现。
特别是循环队列中队头与队尾指针的变化情况;实验环境:Widows操作系统、VC6.0实验原理:1.定义:栈:只允许在一端插入和删除的线性表,允许插入和删除的一端称为栈顶(top),另一端称为栈底(bottom)。
队列: 是只允许在一端删除,在另一端插入的顺序表,允许删除的一端叫做队头(front),允许插入的一端叫做队尾(rear)。
2.特点:栈:后进先出(LIFO)队列:先进先出(FIFO, First In First Out)93. 表示:栈:(1)栈的数组表示—顺序栈(2)栈的链接表示—链式栈队列:(1)队列的顺序存储结构表示——循环队列(2)队列的链式表示—链队列实验内容和要求:分别使用顺序循环队列和堆栈以及链式队列和堆栈编写程序:判断一个字符序列是否是回文。
回文是指一个字符序列以中间字符为基准,两边字符完全相同。
如:“ABCDEDCBA”。
字符串长度小于等于80,用于判断回文的字符串不包括字符串的结束标记符。
基本要求:(1)字符序列可由用户从键盘随意输入;(2)可以连续测试多个字符序列,由用户决定退出测试程序;算法思想:判断回文的算法思想是:把字符串中的字符逐个分别存入队列和堆栈中,然后逐个出队列和退栈并比较出队列的数据元素和退栈的数据元素是否相等,若全部相等则该字符序列为回文,否则就不是回文。
基本操作:回文判断操作主要包括入栈和入队列、退栈和出队列操作。
在对堆栈以及队列进行操作之前,必须对队列以及堆栈进行初始化。
若使用链式堆栈和链式队列,操作结束后必须销毁链表。
二、实验过程:程序流程图:队列实验中的关键语句:(1) 构造空顺序栈算法Status InitStack ( SqStack &S ) {S.base = ( SElemType * ) malloc ( ST ACK_INIT_SIZE * sizeof ( SElemType ) );if ( ! S.base ) exit ( OVERFLOW );S.stacksize = ST ACK_INIT_SIZE;return OK;} // InitStack(2) 顺序栈出栈算法Status Pop ( SqStack &S, SElemType &e ) {if ( S.top = = S.base ) return ERROR;e = *--S.top; return OK;} // Pop(3)(4) 将元素压入顺序栈算法Status Push ( SqStack &S, SElemType e ){if ( S.top - S.base >= S.stacksize ) { S.base = ( SElemType * ) realloc ( S.base, ( S.stacksixe + ST ACKINCREMENT* sizeof ( SElemType ) );if ( ! S.base ) exit ( OVERFLOW );S.top = S.base + S.stacksize;S.stacksize += ST ACKINCREMENT;}*S.top ++= e;return OK;} // Push(4)在顺序队列尾插入新元素算法Status EnQueue ( SqQueue &Q; QElemType e ) {if ( ( Q.rear + 1 ) % MAXQSIZE = = Q.front )return ERRORQ.base[ Q.rear ] = e;Q.rear = ( Q.rear + 1 ) % MAXQSIZE;return OK;} // EnQueue(5)在顺序队列头删除旧元素算法Status DeQueue ( SqQueue &Q, QElemType &e ) {if ( Q.front = = Q.rear ) return ERROR;e = Q.base [ Q.front ]; Q.front = ( Q.front + 1 ) % MAXQSIZE; return OK;} // DeQueue(6)在链式队列尾插入新元素算法Status EnQueue ( LinkQueue &Q; QElemType e ) {p = ( QueuePtr ) malloc ( sizeof ( QNode ) );if ( ! p ) exit ( OVERFLOW ); p->data = e;p->next = NULL;Q.rear->next = p;Q.rear = p;return OK;} // EnQueue(7)在链式队列头删除旧元素算法Status DeQueue ( LinkQueue &Q, QElemType &e ) {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;} // DeQueue编写及调试程序中遇到的问题及解决方法:(1)没有注意到可以验证多次问题。
数据结构-回文序列判断

回文序列判断目录一、实验目的 (2)二、实验内容 (2)三、数据结构及算法思想 (2)四、模块划分 (2)1、对各个模块进行功能的描述 (2)2、模块之间关系及其相互调用的图示 (3)五、详细设计及运行结果 (3)1、设计源代码: (3)2、运行结果: (7)六、调试情况,设计技巧及体味 (7)1、熟悉并掌握栈的的创建、入栈和出栈等基本用法并能运用栈完成一些特定的任务。
2、熟悉并掌握队列的的创建、入队和出队等基本用法并能运用队列完成一些特定的任务。
3、运用栈和队列实现对“回文”序列的判断。
编写一个算法,判断一次读入一个以 @结束符的字母序列,是否为形如‘序列 1&序列2’模式的字符序列。
其中序列 1 和序列 2 中都不含字符‘&’。
且序列2 是序列 1 的逆序列。
例如,‘a+b&b+a’是属于该模式的字符序列,‘a+b&b-a’则不是。
运用栈和队列算法,在序列挨次输入时将序列分别入栈和入队列,利用栈FILO 和队列FIFO 的特点,通过出栈和出队列实现序列顺序和逆序的比较,根据题目描述的回文序列判断并输出结果。
本次设计共分为六个模块,分别是:初始化模块、输入模块、入栈模块、入队模块、判断模块、输出模块。
各个模块功能如下表。
模块功能描述初始化模块栈、队列等初始化输入模块字母序列输入入栈模块将输入序列入栈入队模块将输入序列入队判断模块将序列正、逆比较输出模块判断结果输出#include"stdio.h"#include"conio.h"#include"malloc.h" typedef struct NODE开始初始化模块入栈模块输入模块入队模块比较模块出栈出队列正、逆序判断输出模块结束{char data;struct NODE *next;}LinkStack;typedef struct Node{char data;struct Node *next;}LinkQueueNode;typedef struct{LinkQueueNode *front;LinkQueueNode *rear;}LinkQueue;void InitStack(LinkStack *top){top->next=NULL;}char Push(LinkStack *top,char a){LinkStack *temp;temp=(LinkStack *)malloc(sizeof(LinkStack));if(temp==NULL)return(0);temp->data=a;temp->next=top->next;top->next=temp;return(1);}char Pop(LinkStack *top){LinkStack *temp;char a;temp=top->next;if(temp==NULL)return(0);top->next=temp->next;a=temp->data;free(temp);return(a);}int LengthStack(LinkStack *top){LinkStack *temp;temp=top->next;while(temp!=NULL){count++;temp=temp->next;}return(count);}void InitQueue(LinkQueue *q){q->front=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));q->rear=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));q->rear=q->front;q->front->next=NULL;}char EnterQueue(LinkQueue *q,char a){LinkQueueNode *NewNode;NewNode=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));if(NewNode!=NULL){NewNode->data=a;NewNode->next=NULL;q->rear->next=NewNode;q->rear=NewNode;return(1);}elsereturn(0);}char OutQueue(LinkQueue *q){LinkQueueNode *temp;char a;if(q->rear==q->front)return(0);temp=q->front->next;q->front->next=temp->next;if(q->rear==temp)q->rear=q->front;a=temp->data;free(temp);}void main(){char a[100],flag1=0,flag2=0,n,m;int i=0,t=0;LinkStack *top=(LinkStack *)malloc(sizeof(LinkStack));LinkQueue *q=(LinkQueue *)malloc(sizeof(LinkQueue));InitStack(top);InitQueue(q);printf("please input a string end of @ :\n");while(a[i- 1]!=64){scanf("%c",&a[i]);i++;}for(t=0;t<i;t++){if(a[t]!=64){Push(top,a[t]);EnterQueue(q,a[t]);}}t=LengthStack(top);if(t%2==0)printf("Input wrong!");else{for(i=0;i<t;i++){n=Pop(top);m=OutQueue(q);if(n!=m)flag1=1;if((i==t/2)&&(n!=38))flag2=1;}if(flag1||flag2)printf("This is not palindrome sequence!");elseprintf("This is palindrome sequence!");}getch();}2.1、回文字符序列输入:2.2 非回文字符序列输入:通过这次数据结构试验,我学习了链栈的建立及其一些基本的操作方法和队列的建立及对其的一些基本操作,充分理解了栈和区别和联系,栈和队列都可以通过链表实现,区别在于对其操作的节点位置不同,更重要的是通过这次实践操作学会了完成一个设计的基本方法和步骤,拿到一个问题不能急于开始书写代码要将问题理清晰、找清思路、分好模块再开始敲代码,代码只是实现一个功能的工具,惟独好的解决问题的思路,才干做出好的程序。
回文判断

view sourceprint?01/*------------------------------02 * QQ:12388899403 * Email:six.heyaxiang@04 ------------------------------*/05 /*--------------------------------------06 * 操作目的:判断一个字符序列是否为回文07 * 初始条件:字符序列存在08 * 操作结果:若字符序列为回文,返回true,否则返回false09 * 函数参数:10 * char *str 待判断的字符序列11 *返回值:bool型12 *基本实现思想:构造一个栈和一个队列,让字符序列13 * 做入栈和入队列操作,遇到‘@’停止,14 * 然后依次出栈和出队,依次比较,如果15 * 出栈完成,所有字符相等,说明是回文16 * 否则不是回文17 -------------------------------*/1819booljudgePlalinDrome(constchar*str)20 {21 if(str[0] !='@')22 {23 inti = 0;24 ElemType S = 0;25 ElemType Q = 0;26 SqStack sStr;27 LinkQueue qStr;28 InitStack(&sStr);29 InitQueue(&qStr);30 while(str[i] !='@')31 {32 Push(&sStr,str[i]); //入栈33 EnQueue(&qStr,str[i]); //入队列34 i++;35 }36 while(sStr.top != sStr.base)37 {38 Pop(&sStr,&S); //出栈39 DeQueue(&qStr,&Q);//出队40 if(S != Q)41 {42 break; //如果发现Q != S 停止出栈,否则都出栈43 }4445 }46 if(sStr.top == sStr.base)47 {48 returntrue;49 }50 else51 {52 returnfalse;53 }54 }55 }// File Name: main.cpp//// Destination:利用栈和队列判断字符串是否是回文//------------------------------------------------------ #include <stdio.h>#include <stdlib.h>#include "palindrome.h"int main (){//声明一个栈一个队列SqStack S;LinkQueue L;//初始化一个栈一个队列InitStack (&S);InitQueue (&L);char c[30];ElemType a,b;printf("请输入要判断的字符,以@结束(最多30个字符):"); scanf("%s",c);int i = 0;int flag1 = 0;int flag2 = 0;while (c[i] != '@'){Push(&S,c[i]); //入栈EnQueue(&L,c[i]);//入队列flag1++;i++;}while (!(S.top == S.base)){Pop(&S,&b);//出栈DeQueue(&L,&a);//出队列if (a==b){flag2++;}else{break;}}if (flag1 == flag2){printf("\n是回文!\n\n");}else{printf("\n不是回文!\n\n");}system("pause");return 0;}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
回文序列判断实验报告
系别:通信工程
班级:0905班
学号:18 号
1.实验目的:熟悉栈的各项操作
2.实验内容:
利用栈的操作完成读入的一个以@结尾的字符序列是否是回文序列的判断.
回文序列即正读与反读都一样的字符序列;
例如:123&321@是;
123&4321@、123&312@不是
算法思想:从键盘上读取一个字符,同时存储在顺序栈与链队列之中,直到字符序列的最后一个字符为@停止输入,因为要满足特定的要求:序列1&序列2,故设置夜歌标记量falg=1,判断输入的元素个数是否为奇数个,若为偶数个则令flag=0,若为奇数个继续判断栈的中间元素是否为&,若不是则令flag=0,若是,将栈和队列中的元素依次出列,判断是否相等,若不相等则令flag=0,最后将flag的值返回给主函数,若flag被修改为0说明不是回文序列,否则反之!!
判断回文序列的流程图:
3.实验感想与体会
通过本次的上机,对栈的各项基本操作都有了更好的掌握,同时明白了一些小的细节问题可能会影响到整个程序的正确的运行,本次的实验我通过了运用栈和队列,可以说对队列的一些基本的操作也得以了巩固和提高!更加体会到,自己写程序上机操作的重要性,它要比课本上学的要多得多!
4.附录(源代码及运行图)
#include<stdio.h>
#define MAX 100
typedef struct//栈结构体
{
char e[MAX];
int top;
}SeqStack;
typedef struct NODE//队列结构体
{
char d;
struct NODE *next;
}LinkQN;
typedef struct//封装头指针为指针
{
LinkQN *front;
LinkQN *rear;
}LinkQ;
InitS(SeqStack *s)//初始化顺序栈
{
s->top=-1;
}
int push(SeqStack *s,char ch)//入栈
{
if(s->top==MAX-1)
return(0);
s->top++;
s->e[s->top]=ch;
return(1);
}
int pop(SeqStack *s,char *x)//出栈
{
if(s->top==-1)
return(0);
*x=s->e[s->top];
s->top--;
return(1);
}
void InitQ(LinkQ *q)//链队列初始化
{
q->front=(LinkQN *)malloc(sizeof(LinkQN));
if(!q->front)
{
printf("分配空间失败!");
}
q->rear=q->front;
q->front->next=NULL;
}
int enter(LinkQ *q,char ch)//入队
{
LinkQN *np;
np=(LinkQN *)malloc(sizeof(LinkQN));
if(!np)
return(0);
np->d=ch;
np->next=NULL;
q->rear->next=np;
q->rear=np;
return(1);
}
int deleteq(LinkQ *q,char *c)//出队
{ LinkQN *p;
if(q->front==q->rear)
return(0);
p=q->front->next;
q->front->next=p->next;
if(q->rear==p)
q->rear=q->front;
*c=p->d;
free(p);
return(0);
}
int huiwen(SeqStack *s,LinkQ *q)//回文判断
{
int flag=1,m=0,t=1;
int i;
char ch1,ch2,ch;
InitS(&s);
InitQ(&q);
printf("请输入字符序列当输入字符@时输入结束:\n");
while(ch!='@')
{
ch=getch();
if(ch!='@')
{ printf("%c",ch);
push(&s,ch);
enter(&q,ch);
m++;
}
}
printf("\n输入完成!\n");
printf("按任意键予以判断!\n");
getch();
if(m%2)
{
if(s->e[m/2]=='&')
{
for(i=1;i<(m+1)/2;i++)
{
pop(&s,&ch1);
deleteq(&q,&ch2);
if(ch1!=ch2)
flag=0;
}
}
else flag=0;
}
else flag=0;
return(flag);
}
main()
{
SeqStack *s;
LinkQ *q;
int m;
m=huiwen(*s,&q);
printf("\n");
if(m)
printf("该字符序列是回文序列!\n");
else
printf("该字符序列不是回文序列!\n"); }。