回文实验报告
数据结构回文报告

《数据结构》实验报告实验名称:回文问题的实现姓名:学号:专业班号:实验日期: 2指导教师:问题描述:编程序判断一个字符序列是否是回文。
要求程序从键盘输入一个字符串,长度小于等于80,用于判断回文的字符串中不包括字符串的结束标记。
基本要求:(1)要求字符序列个数n由用户随意确定,且有0<n<81;(2)可连续测试任意多个序列,可由用户退出测试程序;(3)字符序列由用户从键盘输入。
测试数据:(1) abcdcba(2) abcdefghig算法思想:把字符串中的字符逐个分别存入队列和堆栈,然后逐个出队列和退栈并比较出队列的数据元素和腿退栈的数据元素是否相等,若相等则是回文,否则不是。
模块划分:(1)void Palindrome(char str[],int n),判断字符序列是否回文函数。
(2)void EnterStr(char str[],int *n),键盘输入字符序列函数。
(3)void main(void),主函数。
上述三个函数存放在Palindrome.c中。
数据结构:使用顺序堆栈和顺序循环队列辅助字符序列的回文判断。
DataType为char型。
源程序:/*SeqCQu.h*/typedef struct{DataType queue[MaxQueueSize];int rear;int front;}SeqCQueue;void QueueInitiate(SeqCQueue *Q){Q->rear=0;Q->front=0;}int QueueNotEmpty(SeqCQueue Q){if(Q.front==Q.rear) return 0;else return 1;}int QueueAppend(SeqCQueue *Q,DataType x){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){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){if(Q.front==Q.rear){printf("循环队列已空无数据元素可取!\n");return 0;}else{*d=Q.queue[Q.front];return 1;}}/*SeqStk.h*/typedef struct{DataType stack[MaxStackSize];int top;}SeqStack;void StackInitiate(SeqStack *S){S->top=0;}int StackNotEmpty(SeqStack S){if(S.top<= 0) return 0;else return 1;}int StackPush(SeqStack *S,DataType x){if(S->top>=MaxStackSize){printf("堆栈已满无法插入!\n");return 0;}else{S->stack[S->top]=x;S->top ++;return 1;}}int StackPop(SeqStack *S,DataType *d){if(S->top<=0){printf("堆栈以空无数据元素出栈!\n");return 0;}else{S->top--;*d=S->stack[S->top];return 1;}}int StackTop(SeqStack S,DataType *d) {if(S.top<=0){printf("堆栈已空!\n");return 0;}else{*d=S.stack[S.top-1];return 1;}}/*Palindrome.c*/#include<string.h>#include<stdio.h>#define MaxStackSize 80#define MaxQueueSize 80typedef char DataType;#include "SeqStk.h"#include "SeqCQu.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;}}测试情况:程序运行正常,满足要求,实验成功。
数据结构回文实验报告

数据结构回文实验报告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 输出判断结果根据比较结果,输出判断字符串是否为回文。
回文判断实验二

回文判断实验二洛阳理工学院实验报告系别计算机系班级B13053学号B13053235 姓名李登辉2课程名称数据结构实验日期2014.3.28 实验名称栈和队列的基本操作成绩实验目的:熟悉掌握栈和队列的特点,掌握与应用栈和队列的基本操作算法,训练和提高结构化程序设计能力及程序调试能力。
实验条件:计算机一台,Visual C++6.0实验内容:1.问题描述利用栈和队列判断字符串是否为回文。
称正读与反读都相同的字符序列为“回文”序列。
要求利用栈和队列的基本算法实现判断一个字符串是否为回文。
栈和队列的存储结构不限。
2.数据结构类型定义typedef struct{char elem[MAX];int top;}SeqStack; 顺序栈3.模块划分void InitStack(SeqStack *S):栈初始化模块,int Push(SeqStack *S,char x,int cnt):入栈操作int Pop(SeqStack * S,char * x):出栈操作void InitQuene(SeqQuene *Q):队列初始化int EnterQuene(SeqQuene *Q,char x,int cnt):入队操作int DeleteQuene(SeqQuene *Q,char *x,int cnt):出队操作void main():主函数4.详细设计#include<stdio.h>#include<string.h>#define MAX 50#define FALSE 0#define TURE 1//定义栈typedef struct{char elem[MAX];int top;}SeqStack;//定义循环队列typedef struct{char element[MAX];int front;int rear;}SeqQuene;//初始化栈void InitStack(SeqStack *S){S->top = -1;//构造一个空栈}//入栈int Push(SeqStack *S,char x,int cnt){if(S->top == cnt-1)return(FALSE);S->top++;S->elem[S->top] = x;return(TURE);}//出栈int Pop(SeqStack * S,char * x){if(S->top == -1)return(FALSE);else{*x = S->elem[S->top];S->top--;return(TURE);}}//初始化队列void InitQuene(SeqQuene *Q){Q->front = Q->rear = 0;}//入队int EnterQuene(SeqQuene *Q,char x,int cnt) {if((Q->rear+1)%(cnt+1) == Q->front) return(FALSE);Q->element[Q->rear] = x;Q->rear = (Q->rear+1)%(cnt+1);return(TURE);}//出队int DeleteQuene(SeqQuene *Q,char *x,int cnt){if(Q->front == Q->rear)return(FALSE);*x = Q->element[Q->front];Q->front = (Q->front+1)%(cnt+1);return(TURE);}//主函数void main(){int i,cnt,flag;SeqStack s;SeqQuene q;char a[MAX],b[MAX],c[MAX];flag=0;printf("请输入由*结束且小于%d的回文序列:\n",MAX);for(i = 0;i<MAX+1;i++){scanf("%c",&a[i]);if(a[i] == '*')break;}cnt = i;printf("输入了有%d个字符。
回文判断实验报告

回文判断实验报告一(实验题目:回文判断二(实验目的:对于一个从键盘输入的字符串,判断其是否为回文。
回文即正反序相同。
如“abba”是回文,而“abab”不是回文。
三(实验需求:1.数据从键盘读入;2.输出要判断的字符串;3.利用栈的基本操作对给定的字符串判断其是否是回文,若是则输出“Yes”否则输出“No”四(主要实现函数(1)建立顺序栈存储结构typedef struct { }(2)初始化int initstack(Sqstack &s,int maxsize)(3)入栈int enstack(Sqstack &s, char e) (4)出栈int popstack(Sqstack &s,char &e)(5)判断是否为回文int main(){int r; //用于判断是否为回文Sqstack L,Q; //定义两个栈initstack(L,20);initstack(Q,20);int l; //用于记录输入字符的长度 cout<<"请输入字符串长度"; cin>>l;if(l<=0)exit(1);cout<<"输入字符"<<endl;for(int i=1;i<=l;i++) //输入字符 {char p;cin>>p;enstack(L,p); //入栈 L }cout<<endl;for(int m=1;m<=l;m++){char f;f=getstack(L,m); //从栈 L中取元素,在入栈 Qenstack(Q,f);}for(int n=1;n<=l;n++){char a,b; //从栈 L Q 出栈,比较popstack(L,a);popstack(Q,b);if(a!=b)r=1;else r=2;}if(r==1)cout<<"no"<<endl<<endl;五(源程序#include <iostream> using namespace std; typedef char SElemType; typedef struct {SElemType *base;SElemType *top;int stacksize;}Sqstack;int initstack(Sqstack &s,int maxsize) /{s.base=new SElemType[maxsize]; if(!s.base)exit(1);s.top=s.base;s.stacksize=maxsize;return 0;}int enstack(Sqstack &s, char e){if(s.top-s.base==s.stacksize)exit(1); *s.top=e;s.top++;return 0;}int popstack(Sqstack &s,char &e){if(s.top==s.base)exit(1);e=*--s.top;return 0;}int getstack(Sqstack &s,int i) { SElemType *p;p=s.top;for(int j=1;j<=i;j++){p--;}return *p;}int main(){int r; Sqstack L,Q; initstack(L,20); initstack(Q,20);int l; cout<<"请输入字符串长度"; cin>>l;if(l<=0)exit(1);cout<<"输入字符"<<endl;for(int i=1;i<=l;i++) {char p;cin>>p;enstack(L,p); }cout<<endl;for(int m=1;m<=l;m++){char f;f=getstack(L,m);enstack(Q,f);}for(int n=1;n<=l;n++){char a,b;popstack(L,a);popstack(Q,b);if(a!=b)r=1;else r=2;}if(r==1)cout<<"no"<<endl<<endl; else if(r==2)cout<<"yes"<<endl<<endl; else cout<<"发生错误"<<endl;cout<<"继续判断输入Y,退出输入N"<<endl;char d;cin>>d;if(d=='y'||d=='Y')main();else return 0;}五(各功能的运行界面:(1)主界面:(2)输入1,2,3,4四个字符判断是否是回文,运行界面如下:(3)设置字符串长度为5,a,s,d,s,a,判断是否为回文,运行界面如下:。
数学实验报告 关于回文数产生数的检验

数学实验报告姓名:班级:学号:指导老师:1.实验题目:对于一个自然数,若将各位数字倒序排出,加到原来的数字上,反复这样多次后,若能得到一个从左到右读与从右到左读完全一样的数,则称该自然数能产生回文数或者对称数,例如:195就可以产生一个回文数9339,因为195+591=786786+687=14731473+3741=52145214+4125=9339通过编程计算,你能找出多少个能产生回文数的数,又能找出多少个不能产生回文数的数?二者的最小数是多少?注:由于每个自然数可以进行无穷次循环计算,因此不能判定一个自然数进行无穷次计算后一定能或不能产生回文数,所以本次实验中只判定在一万次的循环计算后能否产生回文数。
2.Matlab程序源代码:j=input('请输入测试数上限:')for m=0:1:jnum=m;fprintf('num:%d\n',m);n=0;for h=0:1:10000i=1;jilu=0;while (num/i)>=1;i=i*10;jilu=jilu+1;endi=10;xinshu=0;bianliang=num;while jilu>=1;a=mod(bianliang,i);bianliang=(bianliang-a)/10;xinshu=xinshu+a*10^(jilu-1);jilu=jilu-1;endnum=num+xinshu;i=1;jilu=0;while (num/i)>=1;i=i*10;jilu=jilu+1;endi=10;xinshu=0;bianliang=num;while jilu>=1;a=mod(bianliang,i);bianliang=(bianliang-a)/10;xinshu=xinshu+a*10^(jilu-1);jilu=jilu-1;endif xinshu-num==0n=1;fprintf('原自然数能产生回文数\n');break;endendif n==0;fprintf('原自然数在一万步运算内不能产生回文数\n'); endend3.程序运行结果:注:M文件的文件名为“zhuanhuan”>> zhuanhuan请输入测试数上限:200 j =200num:0原自然数能产生回文数num:1原自然数能产生回文数num:2原自然数能产生回文数num:3原自然数能产生回文数num:4原自然数能产生回文数num:5原自然数能产生回文数num:6原自然数能产生回文数num:7 原自然数能产生回文数num:8原自然数能产生回文数num:9原自然数能产生回文数num:10原自然数能产生回文数num:11原自然数能产生回文数num:12原自然数能产生回文数num:13原自然数能产生回文数num:14原自然数能产生回文数num:15原自然数能产生回文数num:16原自然数能产生回文数num:17原自然数能产生回文数num:18原自然数能产生回文数num:19原自然数能产生回文数num:20原自然数能产生回文数num:21原自然数能产生回文数num:22原自然数能产生回文数num:23原自然数能产生回文数num:24原自然数能产生回文数num:25原自然数能产生回文数num:26原自然数能产生回文数num:27原自然数能产生回文数num:28原自然数能产生回文数num:29num:30原自然数能产生回文数num:31原自然数能产生回文数num:32原自然数能产生回文数num:33原自然数能产生回文数num:34原自然数能产生回文数num:35原自然数能产生回文数num:36原自然数能产生回文数num:37原自然数能产生回文数num:38原自然数能产生回文数num:39原自然数能产生回文数num:40原自然数能产生回文数num:41原自然数能产生回文数num:42原自然数能产生回文数num:43原自然数能产生回文数num:44原自然数能产生回文数num:45原自然数能产生回文数num:46原自然数能产生回文数num:47原自然数能产生回文数num:48原自然数能产生回文数num:49原自然数能产生回文数num:50原自然数能产生回文数num:51 num:52原自然数能产生回文数num:53原自然数能产生回文数num:54原自然数能产生回文数num:55原自然数能产生回文数num:56原自然数能产生回文数num:57原自然数能产生回文数num:58原自然数能产生回文数num:59原自然数能产生回文数num:60原自然数能产生回文数num:61原自然数能产生回文数num:62原自然数能产生回文数num:63原自然数能产生回文数num:64原自然数能产生回文数num:65原自然数能产生回文数num:66原自然数能产生回文数num:67原自然数能产生回文数num:68原自然数能产生回文数num:69原自然数能产生回文数num:70原自然数能产生回文数num:71原自然数能产生回文数num:72原自然数能产生回文数num:73num:74原自然数能产生回文数num:75原自然数能产生回文数num:76原自然数能产生回文数num:77原自然数能产生回文数num:78原自然数能产生回文数num:79原自然数能产生回文数num:80原自然数能产生回文数num:81原自然数能产生回文数num:82原自然数能产生回文数num:83原自然数能产生回文数num:84原自然数能产生回文数num:85原自然数能产生回文数num:86原自然数能产生回文数num:87原自然数能产生回文数num:88原自然数能产生回文数num:89原自然数能产生回文数num:90原自然数能产生回文数num:91原自然数能产生回文数num:92原自然数能产生回文数num:93原自然数能产生回文数num:94原自然数能产生回文数num:95num:96原自然数能产生回文数num:97原自然数能产生回文数num:98原自然数能产生回文数num:99原自然数能产生回文数num:100原自然数能产生回文数num:101原自然数能产生回文数num:102原自然数能产生回文数num:103原自然数能产生回文数num:104原自然数能产生回文数num:105原自然数能产生回文数num:106原自然数能产生回文数num:107原自然数能产生回文数num:108原自然数能产生回文数num:109原自然数能产生回文数num:110原自然数能产生回文数num:111原自然数能产生回文数num:112原自然数能产生回文数num:113原自然数能产生回文数num:114原自然数能产生回文数num:115原自然数能产生回文数num:116原自然数能产生回文数num:117 num:118原自然数能产生回文数num:119原自然数能产生回文数num:120原自然数能产生回文数num:121原自然数能产生回文数num:122原自然数能产生回文数num:123原自然数能产生回文数num:124原自然数能产生回文数num:125原自然数能产生回文数num:126原自然数能产生回文数num:127原自然数能产生回文数num:128原自然数能产生回文数num:129原自然数能产生回文数num:130原自然数能产生回文数num:131原自然数能产生回文数num:132原自然数能产生回文数num:133原自然数能产生回文数num:134原自然数能产生回文数num:135原自然数能产生回文数num:136原自然数能产生回文数num:137原自然数能产生回文数num:138原自然数能产生回文数num:139num:140原自然数能产生回文数num:141原自然数能产生回文数num:142原自然数能产生回文数num:143原自然数能产生回文数num:144原自然数能产生回文数num:145原自然数能产生回文数num:146原自然数能产生回文数num:147原自然数能产生回文数num:148原自然数能产生回文数num:149原自然数能产生回文数num:150原自然数能产生回文数num:151原自然数能产生回文数num:152原自然数能产生回文数num:153原自然数能产生回文数num:154原自然数能产生回文数num:155原自然数能产生回文数num:156原自然数能产生回文数num:157原自然数能产生回文数num:158原自然数能产生回文数num:159原自然数能产生回文数num:160原自然数能产生回文数num:161原自然数能产生回文数num:162原自然数能产生回文数num:163原自然数能产生回文数num:164原自然数能产生回文数num:165原自然数能产生回文数num:166原自然数能产生回文数num:167原自然数能产生回文数num:168原自然数能产生回文数num:169原自然数能产生回文数num:170原自然数能产生回文数num:171原自然数能产生回文数num:172原自然数能产生回文数num:173原自然数能产生回文数num:174原自然数能产生回文数num:175原自然数能产生回文数num:176原自然数能产生回文数num:177原自然数能产生回文数num:178原自然数能产生回文数num:179原自然数能产生回文数num:180原自然数能产生回文数num:181原自然数能产生回文数num:182原自然数能产生回文数num:183原自然数能产生回文数num:184原自然数能产生回文数num:185原自然数能产生回文数num:186原自然数能产生回文数num:187原自然数能产生回文数num:188原自然数能产生回文数num:189原自然数能产生回文数num:190原自然数能产生回文数num:191原自然数能产生回文数num:192原自然数能产生回文数num:193原自然数能产生回文数num:194原自然数能产生回文数num:195原自然数能产生回文数num:196原自然数在一万步运算内不能产生回文数num:197原自然数能产生回文数num:198原自然数能产生回文数num:199原自然数能产生回文数num:200原自然数能产生回文数>>注:上述实验结果实际为一列现实,为使实验报告更加简洁,复制到word中后设置为分三栏显示。
数据结构回文实验报告

数据结构回文实验报告数据结构回文实验报告引言:数据结构是计算机科学中的重要概念,它研究如何组织和管理数据,以便高效地访问和操作。
回文是一种特殊的字符串,它正着读和倒着读都一样。
在本实验中,我们将探索使用不同的数据结构来判断一个字符串是否为回文。
实验目的:1. 了解回文的概念和特点;2. 掌握常见的数据结构,如数组、链表和栈;3. 实践使用不同数据结构来判断字符串是否为回文;4. 比较不同数据结构在回文判断中的性能差异。
实验过程:首先,我们需要定义一个字符串,并将其存储在不同的数据结构中。
我们选择了“level”这个回文字符串作为示例。
1. 数组:我们使用一个字符数组来存储字符串。
首先,我们需要计算字符串的长度,并将每个字符按顺序存储在数组中。
然后,我们使用两个指针,一个指向数组的开头,一个指向数组的末尾,逐个比较它们所指向的字符是否相同。
如果所有字符都相同,则该字符串是回文。
2. 链表:我们使用一个单向链表来存储字符串。
每个节点包含一个字符和一个指向下一个节点的指针。
我们将字符串的每个字符依次插入链表的末尾。
然后,我们使用两个指针,一个指向链表的开头,一个指向链表的末尾,逐个比较它们所指向的字符是否相同。
如果所有字符都相同,则该字符串是回文。
3. 栈:我们使用一个栈来存储字符串。
我们将字符串的每个字符依次入栈。
然后,我们使用两个指针,一个指向栈的顶部,一个指向栈的底部,逐个比较它们所指向的字符是否相同。
如果所有字符都相同,则该字符串是回文。
实验结果:我们对以上三种数据结构进行了回文判断实验,并记录了结果。
在本次实验中,我们发现使用数组和栈的方法可以正确判断字符串是否为回文,而使用链表的方法则无法正确判断。
这是因为链表无法像数组和栈一样快速访问和比较元素。
性能比较:我们进一步比较了使用数组和栈的方法在回文判断中的性能差异。
我们使用了不同长度的字符串进行实验,并记录了执行时间。
实验结果显示,数组的执行时间与字符串长度成正比,而栈的执行时间与字符串长度无关。
洛阳理工学院回文判断

洛阳理工学院实验报告附:源程序:#include<stdio.h>#include<string.h>#define stack_size 50#define TRUE 1#define FALSE 0typedef struct{char elem[stack_size];int top;}seqstack;void setstack(seqstack *S){char x;S->top=-1;if(S->top==stack_size-1) printf("栈已满!\n");else{printf("输入字符串,当输入为空格时停止\n");x=getchar();while(x!=32){S->top++;S->elem[S->top]=x;x=getchar();}S->top++;S->elem[S->top]='\0';}}void Popstack(seqstack *S,seqstack *R){char x;R->top=-1;if(R->top==stack_size-1) printf("新栈已满!\n");else{if(S->top==-1)printf("栈为空");else{S->top--;while(S->top!=-1){x=S->elem[S->top];R->top++;R->elem[R->top]=x;S->top--;}}R->elem[++R->top]='\0';}}int comparestack(seqstack *S,seqstack *R){int flag=1;if(R->top==-1)printf("栈为空\n");else{S->top=0;R->top=0;while(flag){if(S->elem[S->top]!=R->elem[R->top])return(FALSE);if(S->elem[S->top]!='\0'||R->elem[R->top]!='\0'){S->top++;R->top++;}else flag=0;}}return(TRUE);}tuichu (){printf("thank you !\n");exit(0);}main(){seqstack a,b,*S1,*S2;int n,c;S1=&a,S2=&b;printf("\t\t 这是判断回文的函数\n");do{printf("输入0:判断回文\n");printf("输入1:退出程序\n");printf("请选择:");scanf("%d",&n);switch (n){case 0:setstack(S1);Popstack(S1,S2);c=comparestack(S1,S2);if(c==1)printf("该字符串是回文字符串!\n");else printf("该字符串不是回文字符串!\n");break;case 1:tuichu ();}}while(1);}。
回文判断的算法实验报告

实验题目回文判断的算法一、需求分析1.程序的功能:实现对字符序列是否是一个回文序列的判断2.输入输出的要求:从键盘读入一组字符序列,判断是否是回文,并将结果显示在屏幕上3.测试数据:回文字符序列输入:非回文字符序列输入:二、概要设计1.本程序所用的抽象数据类型的定义:typedef struct{char item[STACKSIZE];int top;}SqStack;typedef struct QNode{char data;struct QNode *next;}LQNode, *PQNode;typedef struct{PQNode front,rear;} LinkQueue;2.主程序的流程及各程序模块之间的层次关系。
(1)int InitStack(SqStack *S):栈初始化模块,即初始化一个空栈,随后对该空栈进行数据的写入操作;(2)int Push(SqStack *s, char data):入栈操作,即给空栈中写入数据,数据长度有宏定义给出;(3)int Pop(SqStack *s, char *data):出栈操作,即将栈中的数据输出,由于栈的操作是先进后出,因此,出栈的数据是原先输入数据的逆序;(4)int InitQueue(LinkQueue *q):队列初始化,即初始化一个空队列,最后对该空队列进行数据的写入操作;(5)int EnQueue(LinkQueue *q, char item):入队操作,即给空队列中写入数据,数据长度一样有宏定义给出;(6)int DeQueue(LinkQueue *q, char *item):出队操作,即将队列中的数据输出,由于队列的操作是先进先出,因此,出队的数据室原先输入数据的正序;(7)int main():主函数,用于调用前面的模块,进行出队数据与出栈数据的比较,判断输入的序列是否是回文序列。
模块之间关系及其相互调用的图示:三、详细设计1.采用c语言定义相关的数据类型整形,字符型,指针类型,聚合类型,自定义类型2.写出各模块的伪码算法:参照源程序(1)int InitStack(SqStack *S)(2)int Push(SqStack *s, char data)(3)int Pop(SqStack *s, char *data)(4)int InitQueue(LinkQueue *q)(5)int EnQueue(LinkQueue *q, char item)(6)int DeQueue(LinkQueue *q, char *item)四、调试分析1.调试中遇到的问题及对问题的解决方法: 问题:程序出现未知错误。
数据结构C语言版判断回文数实验报告

数据结构C语言版判断回文数实验报告实验目的:1. 了解回文数的定义和判断方法2. 掌握C语言中字符串的处理方法3. 学习如何使用栈来判断字符串是否为回文数实验原理:回文数是一个正整数,它的各位数字倒过来排列后仍然是同一个数。
比如121、12321就是回文数,而123、56789就不是回文数。
判断一个字符串是否为回文数,可以将字符串中的每一个字符逐个压入栈中,然后再依次将栈中的字符弹出,与原字符串中的字符逐个比较。
实验步骤:1. 定义一个栈结构体,其中包含一个整型数组和一个顶部指针变量。
顶部指针变量用于指向栈顶的位置。
```c#define MAXSIZE 100 // 定义栈中最大元素数量typedef struct {int data[MAXSIZE]; // 栈中元素数据int top; // 栈顶指针} Stack;```2. 定义一个函数用于判断字符串是否为回文数。
函数接收一个字符串指针作为参数。
首先计算字符串的长度,然后将字符串中的每一个字符压入栈中。
接着依次将栈中的字符弹出,与原字符串中的字符逐个比较。
如果两者不同,则说明该字符串不是回文数,函数返回0并退出。
如果所有字符都比较完成后没有发现不同,说明该字符串是回文数,函数返回1并退出。
// 将字符串中的每一个字符压入栈中for (int i = 0; i < len; i++) {s.data[++s.top] = str[i];}return 1;}```3. 在主函数中,首先要输入一个字符串,然后调用is_palindrome函数进行判断,最后输出判断结果。
实验结果:测试数据:输入:"12321"请输入一个字符串:12321该字符串是回文数"abcde""aabbabbaa"分析:实验结果验证了判断回文数的方法和字符串操作的正确性,同时掌握了使用栈来判断字符串是否为回文数的方法,有助于更好地理解栈的概念和应用。
数据结构回文序列判断实验报告简版

数据结构回文序列判断实验报告数据结构回文序列判断实验报告1. 实验目的本实验旨在探究如何使用数据结构来判断一个序列是否为回文序列,并通过实验验证算法的正确性和效率。
2. 实验背景回文序列是指正向和反向读取都相同的序列。
判断一个序列是否为回文序列可以在很多场景下使用,比如判断一个字符串是否为回文串,或者判断一个数字列表是否为回文数字。
回文序列判断问题是数据结构中非常经典的问题之一,能够有效地练习和运用数据结构的知识。
在本实验中,我们将使用栈来实现回文序列的判断。
3. 实验原理与方法3.1 栈的原理栈是一种数据结构,具有先进后出(Last in, First out,LIFO)的特点。
栈的操作主要有入栈和出栈两个动作,入栈将元素放置在栈顶,出栈则将栈顶元素弹出。
3.2 回文序列判断算法回文序列判断算法的基本思路是将原序列中的元素逐个入栈,然后逐个出栈与原序列中的元素进行比较,若相同则继续比较下一个元素,否则返回不是回文序列。
1. 将原序列中的元素逐个入栈。
2. 逐一出栈栈顶元素,并与原序列中的元素逐个比较。
3. 若任一对应位置的元素不相同,则返回不是回文序列。
4. 若所有元素都相同,则返回是回文序列。
3.3 实验步骤1. 创建一个空栈。
2. 将原序列中的元素逐个入栈,直到全部入栈完成。
3. 出栈栈顶元素,并与原序列中的元素逐个比较。
4. 若比较结果不相同,则返回不是回文序列。
5. 若比较结果都相同,重复步骤3和步骤4,直到栈为空。
6. 若全部比较结果都相同,则返回是回文序列。
4. 实验结果与分析为了验证回文序列的判断算法,我们选择了几个不同长度的序列进行实验,并记录下了实验结果。
4.1 实验结果案例1:序列:abcba实验结果:是回文序列案例2:序列:12321实验结果:是回文序列案例3:序列:abccbaa实验结果:不是回文序列4.2 分析通过以上实验结果可以发现,我们设计的回文序列判断算法在大多数情况下都能够正确判断出序列是否为回文序列。
数据结构回文序列判断实验报告

数据结构回文序列判断实验报告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为字符串的长度。
13131116钱剑滨_队列和栈判断回文

13131116钱剑滨_队列和栈判断回文13软工转本1 钱剑滨实验报告利用队列和栈判断回文实验报告信息工程系 13软工转本1 日期 2019年03月20日姓名钱剑滨学号 13131116 电话 [1**********]一、实验内容编写关于栈和队列操作的C 语言程序,要求能判断输入字符串是否为回文(回文:正序和逆序一样)。
二、实验步骤1. 分析栈和队列的实现算法。
2. 编写程序,通过队列来实现字符串正序输出,通过栈来实现字符串逆序输出。
3. 运行程序,纠正错误,对预测结果进行验证。
三、设计概要1. 本实验包含了7个函数:a) 主函数 main()b) 接收字符串函数get_string ()c) 初始化队列函数init_queue ()d) 初始化栈函数 init_stack ()e) 入队函数 enter_queue ()f) 出队函数 out_queue()g) 压栈函数 push ()h) 出栈函数 pop()i) 字符串比较函数contrast()四、程序设计1. 函数前包含的头文件名、结点类型定义、全局变量和函数声明 #include#include#include#define N 100 //输入字符串的最大长度typedef struct SeqQuene //定义循环队列{char *pBase_queue;int front;int rear;}SeqQueue;typedef struct SeqStack //定义栈{char *pBase_stack;int bottom;int top;}SeqStack;/*函数声明*/void get_string(char *string_get, int *qString_side); //接受字符串void init_queue(SeqQueue *queue, int string_side); //初始化队列void init_stack(SeqStack *stack, int string_side); //初始化栈void enter_queue(SeqQueue *queue, char *string_get, intstring_side); //入队void out_queue(SeqQueue *queue, char *string_queue, intstring_side); //出队void push(SeqStack *stack, char *string_get, int string_side); //压栈 void pop(SeqStack *stack, char *string_stack, int string_side);//出栈void contrast(char *string_stack, char *string_queue, int string_side);//字符串比较2. 主函数main()void main(){SeqStack stack; //这里定义普通变量,下面再传地址 SeqQueue queue; //如果定义指针变量会报错 char *string_get, *string_queue, *string_stack;//定义字符指针,分别存放接收字符串、顺序输出字符串、逆序输出字符串int string_side; //定义接收字符串的长度string_get = (char *)malloc(sizeof (char) * N);//给字符指针分配空间,必须在声明的函数内部get_string(string_get, &string_side); //接受字符串string_queue = (char *)malloc(sizeof (char) * (string_side + 1));string_stack = (char *)malloc(sizeof (char) * (string_side + 1));init_queue(&queue, string_side); //初始化队列init_stack(&stack, string_side); //初始化栈enter_queue(&queue, string_get, string_side);out_queue(&queue, string_queue, string_side);push(&stack, string_get, string_side);pop(&stack, string_stack, string_side);contrast(string_stack, string_queue, string_side);}3. 接收字符串函数get_string ()void get_string(char *string_get, int *qString_side) //接收字符串{int string_side;printf("请输入要判断的字符串\n");scanf("%s", string_get);string_side = *qString_side = strlen(string_get);//判断字符串长度printf("输入的字符串长度为%d\n", string_side);}4. 初始化队列函数init_queue ()void init_queue(SeqQueue *queue, int string_side) //初始化队列 {queue->pBase_queue = (char *)malloc(sizeof (char) *(string_side + 1));queue->front = 0;queue->rear = 0;}5. 初始化栈函数init_stack ()void init_stack(SeqStack *stack, int string_side) //初始化栈 {stack->pBase_stack = (char *)malloc(sizeof (char) *(string_side + 1));stack->bottom = -1;stack->top = -1;}6. 入队函数enter_queue ()void enter_queue(SeqQueue *queue, char *string_get, intstring_side) //入队{int i = 0;while((queue->rear+1) % (string_side + 1) != queue->front) //队列满时跳出循环{queue->pBase_queue[queue->rear] = string_get[i]; //依次在队列里添加字符queue->rear = (queue->rear + 1) % (string_side + 1); //循环队列i++;}}7. 出队函数out_queue()void out_queue(SeqQueue *queue, char *string_queue, intstring_side) //出队{int i = 0;while(queue->rear != queue->front) //当队列空时跳出循环{string_queue[i] = queue->pBase_queue[queue->front]; //依次取出队列里字符queue->front = (queue->front + 1) % (string_side + 1);//循环队列i++;}string_queue[i] = '\0'; //字符串结束printf("顺序输出为:");printf("%s\n",string_queue);}8. 压栈函数push ()void push(SeqStack *stack, char *string_get, int string_side) //压栈{int i = 0;while(string_side--){stack->top++; //top指针先后移一位stack->pBase_stack[stack->top] = string_get[i];//一次在栈里添加字符i++;}}9. 出栈函数 pop()void pop(SeqStack *stack, char *string_stack, int string_side) //出栈{int i = 0;while(stack->top != stack->bottom) //栈空时跳出循环{string_stack[i] = stack->pBase_stack[stack->top];//依次取出栈里字符stack->top--; //top指针前移一位i++;}string_stack[i] = '\0'; //字符串结束printf("逆序输出为:");printf("%s\n",string_stack);}10. 字符串比较函数contrast()void contrast(char *string_stack, char *string_queue, int string_side) //字符串比较{int i, k;for(k = 0; k{if(string_stack[k] == string_queue[k]) //字符串中各个元素依次比较i = 1;else{i = 0;break; //只要有一个不同就跳出循环}}if(i)printf("输入字符串是回文\n");elseprintf("输入字符串不是回文\n");}五、测试结果1. 当输入回文字符串时,有如下结果:2. 当输入不是回文字符串时,结果如下:六、总结反思拿到题目时,想到总体思路是让字符串正序和逆序比较。
回文串实验报告

回文串实验报告课程名称:数据结构实验名称:单链表学生姓名:杜克强学生学号:201207092427实验一回文串的基本操作及其应用一、实验目的1、掌握栈和队列的顺序存储结构和链式存储结构,以便在实际中灵活应用。
2、掌握栈和队列的特点,即后进先出和先进先出的原则。
3、掌握栈和队列的基本运算,如:入栈与出栈,入队与出队等运算在顺序存储结构和链式存储结构上的实现。
二、实验内容和要求[问题描述]对于一个从键盘输入的字符串,判断其是否为回文。
回文即正反序相同。
如“abba”是回文,而“abab”不是回文。
[基本要求](1)数据从键盘读入;(2)输出要判断的字符串;(3)利用栈的基本操作对给定的字符串判断其是否是回文,若是则输出“Yes”,否则输出“No”。
[测试数据]由学生任意指定。
三、实验步骤1.需求分析本演示程序用C语言编写,完成对一个字符串是否是回文字符串的判断①输入一个任意的字符串;②对输入的字符串进行判断是否为回文串;③输出判断结果;④测试数据:A.依次输入“abccba”,“asddas”等数据;B.输出判断结果“Yes”,“No”等四、算法设计1、算法思想:把字符串中的字符逐个分别存储到队列和堆栈中,然后逐个出队和出栈并比较出队列的数据元素和退栈的数据元素是否相等,若相等则是会文,否则不是。
2、模块设计(1)int Palindrome_Test()判断字符序列是否为回文串;(2)Status main()主函数;(3)Status CreatStack(SqStack &S)创建一个栈;(4)Status Push(SqStack &S,SElemType e)入栈;(5)Status Pop(SqStack &S ,SElemType &e)出栈;(6)Status CreatQueue(LinkQueue &Q)创建一个队列;(7)Status EnQueue(LinkQueue &Q,QElemType e)入队;(8)Status DeQueue(LinkQueue &Q,QElemType &e)出队;3、模块之间关系及其相互调用的图示4、数据存储结构图五、调试分析一、实验结果图2 实验结果二、总结通过做回文串实验让我同时用到了栈和队列两种结构,让我对这两种结构有了一个比较深入的了解和应用,对我以后的编程产生了比较深远的影响。
实验报告1 回文

实验报告1 判断字符串回文一.个人信息:姓名:刘松班级:数学院09级专业班校园卡号:320090924351设计日期:2011.10.7.上机环境:Visual C++ 6.0二.程序设计:1. 实验题目:编写一个程序,判断一个字符串是否为“回文”(顺读和倒读都一样的字符串称为“回文”)。
并分析算法的时间复杂度。
2. 实验项目组成:字符串输入;设立字符指针;字符串“回文”判断;算法的时间复杂度分析。
3. 算法描述:1.输入字符串;2.设立字符串指针*r,*p,r为头指针,p为尾指针;3.p向前遍历,r向后遍历,比较*r,*p是否相等,否,返回;是,p——,r++4. if(p<r) 是回文,否则不是。
4.时间复杂度分析:n为字符串数组a[]的大小,可知其执行次数为n,故时间复杂度为o(n).三.程序及结果:#include<iostream>using namespace std;void main(){int const n=9;char a[n]="asdffdsa";char *r,*p;r=a;p=r+7 ;while(r<p){if(*r==*p) {r++;p--;}else break;}if(p<r)cout<<"a 是回文:"<<endl; elsecout<<"a 不是回文:"<<endl; }2.结果:a 是回文:Press any key to continue 四.程序改进:1.字符串可改为动态输入;2.字符串数组可由静态改为动态;3.判断回文可写成函数放在头文件中。
Java实验--关于简单字符串回文的递归判断实验

Java实验--关于简单字符串回⽂的递归判断实验⾸先题⽬要求写的是递归的实验,⼀开始没注意要求,写了⾮递归的⽅法。
浪费了⼀些时间,所谓吃⼀堑长⼀智。
我学习到了以后看实验的时候要认真看实验中的要求,防⽌再看错。
以下是对此次的实验进⾏的分析:1)递归是运⽤到了栈的思想2)回⽂是⼀段从中间开始倒置的⽂字,回代的过程中出现不同的符号的时候就说明这段⽂字不是回⽂了根据上⾯对回⽂判断的分析,就拿最简单的121来说,要每个字符判断直⾄2所在的位置,然后依次回代判断前⾯的1和后⾯的1的位置(上述的描述就类似于栈的思想)。
有关于栈还有递归其实我并不熟悉,所以此次的实验对我来说算是⼀次挑战吧。
接下来贴出实验的代码(利⽤递归实现回⽂的判断):package huiwen;import java.util.Scanner;public class Huiwen {public static void main(String arg[]){String sz=new String();Scanner scan=new Scanner(System.in);while(!sz.equals("-1")){System.out.println("-------------------------------------\n请输⼊⼀个字符串判断是不是回⽂(输⼊-1结束输出):");if(scan.hasNext()){sz=scan.next();if(sz.equals("-1"))break;}if(isHuiwen(sz,0)) //给递归⼀个起点直⾄字符串的中间,并判断中途有没有不等的情况,如果出现中途不等返回false,反之返回trueSystem.out.println("该字符串是回⽂\n");else System.out.println("该字符串不是回⽂\n");}scan.close();System.out.println("结束判断");}public static boolean isHuiwen(String s,int n){int num=s.length();if(num/2!=n){if(isHuiwen(s,n+1)){if(s.charAt(n)==s.charAt(num-n-1))return true;else return false;}}else if(s.charAt(n)==s.charAt(num-n-1))return true;return false;}}回⽂的实验截图,在判断的过程中没有错误。
堆栈判断回文实验报告

一、实验目的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 << "该字符串是回文。
数据结构C语言版判断回文数实验报告

{ char element[MAX]; int front; int rear; }SeqQuene; //初始化栈 void InitStack(SeqStack *S) { S->top = -1;//构造一个空栈 } //入栈 int Push(SeqStack *S,char x,int cnt) { if(S->top == cnt-1) return(FALSE); S->top++; S->elem[S->top] = x; return(TURE); } //出栈 int Pop(SeqStack * S,char * x) { if(S->top == -1) return(FALSE); else { *x = S->elem[S->top]; S->top--; return(TURE); } } //初始化队列 void InitQuene(SeqQuene *Q) { Q->front = Q->rear = 0; } //入队 int EnterQuene(SeqQuene *Q,char x,int cnt) {
三、数据结构及算法思想 算法思想:从键盘上读取一个字符,同时存储在顺序栈与链队列之中,直到字符序列的 最后一个字符为*停止插入。在程序中设置了一个标志位 flag,将输入的序列分别做入栈、 出栈、入队、出队操作,若出栈与出队的数据完全一致,则将 flag 标志为 1,否则为零。Flag 为 1,则表示该序列是回文序列,否则,为非回文序列。 四、模块划分 1. 对各个模块进行功能的描述 (1)void InitStack(SeqStack *S):栈初始化模块,即初始化一个空栈,随后对该空 栈进行数据的写入操作; (2)int Push(SeqStack *S,char x,int cnt):入栈操作,即给空栈中写入数据,数据长 度有宏定义给出; (3)int Pop(SeqStack * S,char * x):出栈操作,即将栈中的数据输出,由于栈的操 作是先进后出,因此,出栈的数据是原先输入数据的逆序; (4)void InitQuene(SeqQuene *Q):队列初始化,即初始化一个空队列,最后对该 空队列进行数据的写入操作; (5)int EnterQuene(SeqQuene *Q,char x,int cnt):入队操作,即给空队列中写入数 据,数据长度一样有宏定义给出; (6)int DeleteQuene(SeqQuene *Q,char *x,int cnt):出队操作,即将队列中的数据 输出,由于队列的操作是先进先出,因此,出队的数据室原先输入数据的正序; (7)void main():主函数,用于调用前面的模块,进行出队数据与出栈数据的比 较,判断输入的序列是否是回文序列。 2. 模块之间关系及其相互调用的图示
回文实验报告

回文判断实验报告问题描述: (2)一、需求分析 (2)二、概要设计 (3)三、详细设计 (3)四、调试分析 (6)六、测试数据 (6)七、课设总结 (7)问题描述:对于一个从键盘输入的字符串,判断其是否为回文。
回文即正反序相同。
如“abba”是回文,而“abab”不是回文。
一、需求分析(1)数据从键盘读入;(2)输出要判断的字符串;(3)利用栈的基本操作对给定的字符串判断其是否是回文,若是则输出“Yes”,否则输出“No”。
二、概要设计抽象数据类型栈定义如下ADT stack{数据对象:D={ai|ai,ElenSet∈i=1,2,……,n,n≥0}数据关系:R1={<a,ai>|1-i a,ai∈D,i=2,……n};1-i约定a端为栈顶,1a端为栈底n基本操作:InitStack(&s)操作结果:构造一个空栈push(&s,e)初始条件:栈s存在操作结果:插入元素e作为新的栈顶元素pop (&s,&e)初始条件:栈s存在操作结果:删除栈s的栈顶元素,并用e返回其值}三、详细设计#include<stdio.h>#include<stdlib.h>#include<string>#define TRUE 1#define FALSE 0#define Stack_Size 100 //定义栈的最大容量#define STACKINCREMENT 10typedef struct{char *base;char *top;int stacksize;}SqStack;int InitStack(SqStack &S)//构造一个空栈{S.base=(char*)malloc(Stack_Size*sizeof(char));if(!S.base)exit(FALSE);S.top=S.base;S.stacksize=Stack_Size;return TRUE;}void Push(SqStack &S,char x)//进栈函数{if(S.top-S.base>=S.stacksize){S.base=(char*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(char));if(!S.base)exit(FALSE);S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=x;}char Pop(SqStack &S,char &c)//出栈函数{if(S.top==S.base)return FALSE;c=*--S.top;return c;}int main(){SqStack S;InitStack(S);char a[30];char c;char e;int k=0;printf("请输入要转换的的字符串,以#号结束:\n"); for(int i=0;i<30;i++){scanf("%c",&c);if(c!='#'){a[i]=c;}else{k=i;break;}}for(int h=0;h<k;h++){Push(S,a[h]);}int count=0;//定义一个计时器for(int w=0;w<k;w++){char x=Pop(S,e);printf("%c",x);if(a[w]==x){count++;}}printf("\n");if(count==k){printf("是回文\n");return TRUE;}else{printf("不是回文\n");return FALSE;}printf("\n");}四、调试分析对于语句中的一般回文单词能正常输出,句末跟标点符号连在一起的回文单词也能通过程序把字符串末尾的标点给去掉并正常输出,而字符串中的连接符可以作为回文单词的组成部分一起输出。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验题目回文判断的算法班级通信143 姓名刘峻霖学号********** 日期 2015年6月17日星期三一、需求分析1.程序的功能:实现对字符序列是否是一个回文序列的判断2.输入输出的要求:从键盘读入一组字符序列,判断是否是回文,并将结果显示在屏幕上3.测试数据:回文字符序列输入:非回文字符序列输入:二、概要设计1.本程序所用的抽象数据类型的定义:typedef struct{char item[STACKSIZE];int top;}SqStack;typedef struct QNode{char data;struct QNode *next;}LQNode, *PQNode;typedef struct{PQNode front,rear;} LinkQueue;2.主程序的流程及各程序模块之间的层次关系。
(1)int InitStack(SqStack *S):栈初始化模块,即初始化一个空栈,随后对该空栈进行数据的写入操作;(2)int Push(SqStack *s, char data):入栈操作,即给空栈中写入数据,数据长度有宏定义给出;(3)int Pop(SqStack *s, char *data):出栈操作,即将栈中的数据输出,由于栈的操作是先进后出,因此,出栈的数据是原先输入数据的逆序;(4)int InitQueue(LinkQueue *q):队列初始化,即初始化一个空队列,最后对该空队列进行数据的写入操作;(5)int EnQueue(LinkQueue *q, char item):入队操作,即给空队列中写入数据,数据长度一样有宏定义给出;(6)int DeQueue(LinkQueue *q, char *item):出队操作,即将队列中的数据输出,由于队列的操作是先进先出,因此,出队的数据室原先输入数据的正序;(7)int main():主函数,用于调用前面的模块,进行出队数据与出栈数据的比较,判断输入的序列是否是回文序列。
模块之间关系及其相互调用的图示:三、详细设计1.采用c语言定义相关的数据类型整形,字符型,指针类型,聚合类型,自定义类型2.写出各模块的伪码算法:参照源程序(1)int InitStack(SqStack *S)(2)int Push(SqStack *s, char data)(3)int Pop(SqStack *s, char *data)(4)int InitQueue(LinkQueue *q)(5)int EnQueue(LinkQueue *q, char item)(6)int DeQueue(LinkQueue *q, char *item)四、调试分析1.调试中遇到的问题及对问题的解决方法:问题:程序出现未知错误。
方法:在感觉容易出错的地方或者是已经出错的地方前面打断点,进一步调试。
2.算法的时间复杂度和空间复杂度。
时间复杂度:T(n) = O(n)五、使用说明及测试结果回文字符输入:非回文字符输入:六、源程序(带注释)#include <stdio.h>#include <stdlib.h>#include <string.h>#define STACKSIZE 100typedef struct{char item[STACKSIZE];int top;}SqStack;/*顺序栈的定义*/typedef struct QNode{char data;struct QNode *next;}LQNode, *PQNode;typedef struct{PQNode front,rear;} LinkQueue;/*链队列的定义*/int InitStack(SqStack *S);/*初始化顺序栈*/int StackEmpty(SqStack S);/*判断是否为空栈*/int Push(SqStack *s, char data);/*入栈*/int Pop(SqStack *s, char *data);/*出栈*/int InitQueue(LinkQueue *q);/*初始化链队列*/int QueueEmpty(LinkQueue q);/*判断是否为空队列*/ int EnQueue(LinkQueue *q, char item);/*入队*/int DeQueue(LinkQueue *q, char *item);/*出队*/ int TraverseQueue(LinkQueue q);/*遍历*/int InitStack(SqStack *S)/*初始化顺序栈*/{S->top = -1;return 1;}int StackEmpty(SqStack S)/*判断是否为空栈*/{if(S.top == -1) return 1;else return 0;}int Push(SqStack *s, char data)/*入栈*/{if(s->top == STACKSIZE - 1){printf("\n栈已满,不能完成入栈操作!");return 0;}s->top++;s->item[s->top] = data;return 1;}int Pop(SqStack *s, char *data)/*出栈*/{if (s->top == -1){printf("\n堆栈已空,不能完成出栈操作!");return 0;}*data = s->item[s->top];s->top--;return 1;}int InitQueue(LinkQueue *q)/*初始化链队列*/{q->front = q->rear = (PQNode)malloc(sizeof(LQNode)); if(!q->front){printf("\n初始化队列失败!");return 0;}q->front->next = NULL;return 1;}int QueueEmpty(LinkQueue q)/*判断是否为空队列*/{if (q.front == q.rear){printf("\n队列为空!");return 1;}else return 0;}int EnQueue(LinkQueue *q, char item)/*入队*/{PQNode p;p = (PQNode)malloc(sizeof(LQNode));if(!p){printf("\n内存分配失败");return 0;}p->data = item;p->next = NULL;q->rear->next = p;q->rear = p;return 1;}int DeQueue(LinkQueue *q, char *item)/*出队*/{PQNode p;if(q->front == q->rear){printf("\n队列已空,不能出队");return 0;}p = q->front->next;*item = p->data;q->front->next = p->next;free(p);if(q->rear == p) /*若删除的为最后一个结点,移动队尾指针*/ q->front = q->rear;return 1;}int TraverseQueue(LinkQueue q)/*遍历*/{PQNode pos;if(q.front == q.rear){printf("\n队列为空!");return 0;}pos = q.front->next;printf("\nHere is the string:"); while(pos != NULL){printf("%c", pos->data);pos = pos->next;}printf("\n");return 1;}int main(){int i,len,count1 = 0;char str1[100],ch,ch1;LinkQueue lq1,lq2;SqStack sq;printf("请输入字符:");scanf("%s", &str1);len = strlen(str1);InitQueue(&lq1);InitQueue(&lq2);InitStack(&sq);for(i=0;i<len;i++){EnQueue(&lq1,str1[i]);}TraverseQueue(lq1);for(i=0;i<len;i++){DeQueue(&lq1,&ch);Push(&sq,ch);EnQueue(&lq1,ch);}for(i=0;i<len;i++){Pop(&sq,&ch);EnQueue(&lq2,ch);}TraverseQueue(lq2);for(i=0;i<len;i++){DeQueue(&lq1,&ch);DeQueue(&lq2,&ch1);if(ch1 != ch) count1++;}if(count1 == 0){printf("\n该字符串为回文"); }elseprintf("\n该字符串不是回文"); return 0;}。