数据结构C语言版判断回文数试验报告
数据结构回文实验报告
数据结构回文实验报告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 输出判断结果根据比较结果,输出判断字符串是否为回文。
数据结构C语言队列-回文
实验课题一:回文(palindrome)是指一个字符串从前面读和从后面读都一样,仅使用若干栈和队列、栈和队列的ADT函数以及若干个int类型和char类型的变量,设计一个算法来判断一个字符串是否为回文。
假设字符串从标准输入设备一次读入一个字符,算法的输出结果为true或者false。
可以用一些字符串测试输出结果,如:"abcdeabcde","madamimadam" 等#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");while((c=getchar())!='!'){putchar(c);stpush(s,c);enqueue(q,c);}printf("\n");printf("End input!\n");while(stempty(s)){if(stpop(s)==dequeue(q)){flag=1;continue;}else{flag=0;break;}}if(flag==1)printf("This string is palindrome!\n");elseprintf("This string isn't palindrome!\n"); }int stinit(stackstru *s){s->top=0;return 1;} //初始化栈int stempty(stackstru *s){if(s->top==0){return 0;}else{return 1;} //判断栈是否空int stpush(stackstru *s,char x){if(s->top==m) //栈满{printf("The stack is overflow!\n");return 0;}else //栈未满{s->top=s->top+1; //栈顶后移s->stack[s->top]=x; //字符入栈return 1;}} //入栈操作char stpop(stackstru *s){char y;if(s->top==0) //栈为空{printf("The stack is empty!\n");return ' '; //返回空格}else //栈不为空{y=s->stack[s->top]; //取出栈顶元素s->top=s->top-1; //栈顶指示移动return y;}} //出栈操作int quinit(queuestru *q){q->front=0;q->rear=0;return 1;} //初始化为一个空的循环队列int quempty(queuestru *q){if(q->front==q->rear) //队头和队尾相等{return 0;else{return 1;}} //判断队列是否为空int enqueue(queuestru *q,char e){if((q->rear+1)%m==q->front) //队列已满{printf("The queue is overflow!\n"); //提示信息return 0;}else{q->queue[q->rear]=e; //入队q->rear=(q->rear+1)%m; //移动队尾指针return 1;}} //入队操作char dequeue(queuestru *q){char f;if(q->front==q->rear) //队列为空{printf("The queue is empty!\n"); //提示信息return 0;}else{f=q->queue[q->front]; //取出队首元素q->front=(q->front+1)%m; //移动对头指针return f;}} //出队操作。
回文判断实验二
回文判断实验二洛阳理工学院实验报告系别计算机系班级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个字符。
实验报告
实验报告题目回文测试姓名周海良学号200907010401.问题描述:编程判断一个字符序列是否是回文(回文是指一个字符序列以中间字符为基准两边字符完全相同如abccba即回文)。
要求程序从键盘输入一个字符串,字符串长度小于20,用于判断回文的字符串中不包含字符串结束标记符。
2.基本要求:①要求字符序列个数n可由用户随意确定,且0<n<20;②可连续测试任意多个字符序列,可由用户决定退出测试程序;③字符序列由用户从键盘输入④利用栈和队列实现。
3.测试数据①abcdcba②abcdefghi一.头文件#define max 20typedef struct{elemtype data[max];int top;}stack;//定义栈的类型void initstack(stack &S){S.top=-1;}//初始化栈void push(stack &S,elemtype x){if(S.top==max-1){cout<<"stack is full!";return;}S.top++;S.data[S.top]=x;}//进栈void pop(stack &S,elemtype &x){if(S.top==-1){cout<<"stack is empty!";return;}x=S.data[S.top];S.top--;}//出栈typedef struct{elemtype data[max];int front,rear;}squeue;//定义队的类型void initqueue(squeue &Q){Q.front=Q.rear=0;}//初始化队void enqueue(squeue &Q,elemtype &x) {if((Q.rear+1)%max==Q.front){cout<<"queue is full!";return;}Q.rear=(Q.rear+1)%max;Q.data[Q.rear]=x;}//进队void outqueue(squeue &Q,elemtype &x) {if(Q.rear==Q.front){cout<<"queue is empty!";return;}Q.front=(Q.front+1)%max;x=Q.data[Q.front];}//出队//回文函数的定义void huiwen(elemtype a[],int n){stack A;squeue B;initstack (A);initqueue(B);int i=0;for(i=0;i<n;i++){push(A,a[i]);enqueue(B,a[i]);}for(i=0;i<n;i++){elemtype x,y;pop(A,x);outqueue(B,y);if(x!=y){cout<<"不是回文!";return;}}cout<<"该字符串是回文!"<<endl;}二.Cpp文件#include"iostream.h"typedef char elemtype;#include"huiwen.h"void f(){int n;cout<<"请确定将要输入字符的长度n(0<n<20):"<<endl;cin>>n;if(n<0||n>20){cout<<"输入不符合要求,重新输入n:";return;}char a[20];cout<<"请输入长度为n的字符串:";for(int i=0;i<n;i++){cin>>a[i];}huiwen (a,n);}void main(){while(true){cout<<"\n回文测试:"<<endl;cout<<"r退出(e或E)"<<endl;char sel;cin>>sel;if(sel=='e'||sel=='E')return;f();}}。
回文数据结构
判断是否为回文实验报告信息系日期姓名学号 88 电话一、实验内容输入一串字符序列以*为结束标志,用栈和队列来判断此字符序列是否为回文。
二、实验步骤1.分析操作所需思路,熟练运用栈和队列的特点。
2.编写程序,利用函数特性进行操作。
3.运行程序,纠正错误,对预测结果进行验证。
4.分析队列和栈的特点,并可以做到熟练掌握队列的初始化,入队,出队与栈的初始化,入队和出队。
三、设计概要1.本实验包含了6个模块初始化堆栈模块void Initialize(Seqstack *s)入栈模块int Push(Seqstack *s,char x,int count)出栈模块int Pop(Seqstack *s,char *p)初始化队列模块void Initquene(Seqquene *p)入队模块int Enterquene(Seqquene *p,char a,int count)出队模块int Outquene(Seqquene *p,char *a,int count)2、明确函数的功能a)void Initialize(Seqstack *s)初始化栈,使它变为一个空栈b)int Push(Seqstack *s,char x,int count)入栈,把数据放入栈中c)int Pop(Seqstack *s,char *p)将栈中的数据输出,栈是先进后出d)void Initquene(Seqquene *p)初始化队列,使它变成一个空的队列e)int Enterquene(Seqquene *p,char a,int count)入队,把数据放入队列中f)int Outquene(Seqquene *p,char *a,int count)出队,队列是先进先出四、设计细节1、定义栈typedef struct{char num[MAX];int top;}Seqstack;2.定义队列typedef struct{char number[MAX];int rear,front;}Seqquene;3. 定义每个函数的返回值类型与形参类型void Initialize(Seqstack *s)int Push(Seqstack *s,char x,int count)int Pop(Seqstack *s,char *p)void Initquene(Seqquene *p)int Enterquene(Seqquene *p,char a,int count)int Outquene(Seqquene *p,char *a,int count)五、程序设计1.函数前包含的头文件名和定义栈和队列#include <stdio.h>#include <string.h>#define MAX 200typedef struct{char num[MAX];int top;}Seqstack;typedef struct{char number[MAX];int rear,front;}Seqquene;2.初始化栈void Initialize(Seqstack *s){s->top=-1;}3.入栈int Push(Seqstack *s,char x,int count){if(s->top==count-1)return 0;s->top++;s->num[s->top]=x;return 1;}4.出栈int Pop(Seqstack *s,char *p){if(s->top==-1){return 0;}else{*p=s->num[s->top];s->top--;return 1;}}5.初始化队列void Initquene(Seqquene *p){p->front=p->rear=0;}6.入队int Enterquene(Seqquene *p,char a,int count) {if((p->rear+1)%(count+1)==p->front){return 0;}p->number[p->rear]=a;p->rear=(p->rear+1)%(count+1);return 1;}7.出队int Outquene(Seqquene *p,char *a,int count) {if(p->front==p->rear){return 0;}*a=p->number[p->front];p->front=(p->front+1)%(count+1);return 1;}8.主函数main()void main(){int i,count,flag=0;Seqquene p;Seqstack s;char a[MAX],b[MAX],c[MAX];printf("请输入一组回文,结束时输入*\n");for(i=0;i<50;i++){scanf("%c",&a[i]);if(a[i]=='*')break;}count=i;Initialize(&s);Initquene(&p);for(i=0;i<count+1;i++){Enterquene(&p,a[i],count);Push(&s,a[i],count);}for(i=0;i<count+1;i++){Outquene(&p,&b[i],count);Pop(&s,&c[i]);if(b[i]==c[i])flag=1;else{flag=0;break;}}if(flag==1) flag=1;else{flag=0;break;}}if(flag==1)printf("此序列为回文");elseprintf("此序列不为回文");}六、程序源码#include <stdio.h>#include <string.h>#define MAX 200//定义栈typedef struct{char num[MAX];int top;}Seqstack;//队列typedef struct{char number[MAX];int rear,front;}Seqquene;//初始化栈void Initialize(Seqstack *s){s->top=-1;}//入栈int Push(Seqstack *s,char x,int count){if(s->top==count-1)return 0;s->top++;s->num[s->top]=x;return 1;}//出栈int Pop(Seqstack *s,char *p){if(s->top==-1){return 0;}else{*p=s->num[s->top];s->top--;return 1;}}//初始化队列void Initquene(Seqquene *p){p->front=p->rear=0;}//入队int Enterquene(Seqquene *p,char a,int count) {if((p->rear+1)%(count+1)==p->front){return 0;}p->number[p->rear]=a;p->rear=(p->rear+1)%(count+1);return 1;}//出队int Outquene(Seqquene *p,char *a,int count) {if(p->front==p->rear){return 0;}*a=p->number[p->front];p->front=(p->front+1)%(count+1);return 1;}void main(){int i,count,flag=0;Seqquene p;Seqstack s;char a[MAX],b[MAX],c[MAX];printf("请输入一组回文,结束时输入*\n");for(i=0;i<50;i++){scanf("%c",&a[i]);if(a[i]=='*')break;}count=i;Initialize(&s);Initquene(&p);for(i=0;i<count+1;i++){Enterquene(&p,a[i],count);Push(&s,a[i],count);}for(i=0;i<count+1;i++){Outquene(&p,&b[i],count);Pop(&s,&c[i]);if(b[i]==c[i])flag=1;else{flag=0;break;}}if(flag==1) flag=1;else{flag=0;break;}}if(flag==1)printf("此序列为回文");elseprintf("此序列不为回文");}七、测试结果1.最初运行的结果如下,有如下结果如下2.当输入回文的结果如下3.当输入的不是回文的时候,结果如下八、总结。
数据结构回文实验报告
数据结构回文实验报告数据结构回文实验报告引言:数据结构是计算机科学中的重要概念,它研究如何组织和管理数据,以便高效地访问和操作。
回文是一种特殊的字符串,它正着读和倒着读都一样。
在本实验中,我们将探索使用不同的数据结构来判断一个字符串是否为回文。
实验目的:1. 了解回文的概念和特点;2. 掌握常见的数据结构,如数组、链表和栈;3. 实践使用不同数据结构来判断字符串是否为回文;4. 比较不同数据结构在回文判断中的性能差异。
实验过程:首先,我们需要定义一个字符串,并将其存储在不同的数据结构中。
我们选择了“level”这个回文字符串作为示例。
1. 数组:我们使用一个字符数组来存储字符串。
首先,我们需要计算字符串的长度,并将每个字符按顺序存储在数组中。
然后,我们使用两个指针,一个指向数组的开头,一个指向数组的末尾,逐个比较它们所指向的字符是否相同。
如果所有字符都相同,则该字符串是回文。
2. 链表:我们使用一个单向链表来存储字符串。
每个节点包含一个字符和一个指向下一个节点的指针。
我们将字符串的每个字符依次插入链表的末尾。
然后,我们使用两个指针,一个指向链表的开头,一个指向链表的末尾,逐个比较它们所指向的字符是否相同。
如果所有字符都相同,则该字符串是回文。
3. 栈:我们使用一个栈来存储字符串。
我们将字符串的每个字符依次入栈。
然后,我们使用两个指针,一个指向栈的顶部,一个指向栈的底部,逐个比较它们所指向的字符是否相同。
如果所有字符都相同,则该字符串是回文。
实验结果:我们对以上三种数据结构进行了回文判断实验,并记录了结果。
在本次实验中,我们发现使用数组和栈的方法可以正确判断字符串是否为回文,而使用链表的方法则无法正确判断。
这是因为链表无法像数组和栈一样快速访问和比较元素。
性能比较:我们进一步比较了使用数组和栈的方法在回文判断中的性能差异。
我们使用了不同长度的字符串进行实验,并记录了执行时间。
实验结果显示,数组的执行时间与字符串长度成正比,而栈的执行时间与字符串长度无关。
《C语言及程序设计》实践参考——回文数
《C语⾔及程序设计》实践参考——回⽂数返回:【项⽬4-回⽂数】(1)输⼊⼀个正整数,判断其是否为⼀个回⽂数(例1221、12321都是回⽂数,正着看、倒着看,是同⼀个数)。
[参考解答]#include <stdio.h>int main(){int n,m,k;scanf("%d", &n);k=n;m=0; //m将为n的反序数while(k>0){m=m*10+k%10;k=k/10;}if(m==n) //n等于其反序数,则为回⽂数printf("Yes\n");printf("\n");return 0;}(2)输出10000以内的所有回⽂数。
[参考解答]解法1:#include <stdio.h>int main(){int n,m,k;int count=0;for(n=1; n<10000; n++){k=n;m=0; //m将为n的反序数while(k>0){m=m*10+k%10;k=k/10;}if(m==n) //n等于其反序数,则为回⽂数{printf("%d\t", n);count++;if(count%8==0)printf("\n");}}return 0;}解法2:#include <stdio.h>int main(){int m,n;//个位数全是回⽂数for(m=1; m<=9; ++m)printf("%d\t", m);//下⾯凑出所有两位的回⽂数for(m=1; m<=9; ++m)printf("%d\t", m*10+m);//下⾯凑是所有三位的回⽂数for(m=1; m<=9; ++m)for(n=0; n<=9; ++n)printf("%d\t", m*100+n*10+m);//下⾯凑出所有四位的回⽂数for(m=10; m<=99; ++m){n=(m%10)*10+m/10; //n和m⽐,个位、⼗位恰互换 printf("%d\t", m*100+n);}printf("\n");return 0;}。
回文判断的算法实验报告
实验题目回文判断的算法一、需求分析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.实验总结本实验通过使用数据结构中的栈,成功判断了一个给定序列是否为回文序列。
通过实验过程,我们深入理解了栈的应用和回文序列的判断原理,并熟悉了实际编程的过程。
同时,我们也认识到了栈在解决一些问题时的便捷性和高效性。
在今后的学习和工作中,我们将更加熟练地运用栈来解决问题。
数据结构C语言用栈判断回文数
printf(" 用栈判断字符串是否为回文数\n");
Judgment(S);
}
}
if(len%2==0)
{
next=mid;
}
else
{
next=mid+1;
}
for(i=next;i<=len-1;i++)
{
if(a[i]==S->data[S->top])
{
Pop(S,x);
}
else break;
{
return(S->top==MAXSIZE-1?1:0);
}
int Push(SqStack *S,DataType e)//进栈
{
if(StackFull(S))
return 0;
S->top++;
S->data[S->top]=e;
return 1;
}
int Pop(SqStack *S,DataType e)//出栈
}SqStack;
int InitStack(SqStack *S)//初始化栈
{
S->top=-1;
return 1;
}
int StackEmpty(SqStack *S)//判栈空
{
return(S->top==-1?1:0);
}
int StackFull(SqStack *S)//判栈满
#include<stdio.h>
#include<string.h>
实验报告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.判断回文可写成函数放在头文件中。
实验3回文判断
实验题目:回文判断实验描述:判断依次读入的一个以@为结束符的字母序列,是否为形如‘序列1&序列2’模式的字符序列。
其中序列1和序列2中都不含字符‘&’,且序列2是序列1的逆序列。
程序设计#include<stdio.h>#include<stdlib.h>typedef struct Node /*定义队列结点类型*/{char data;struct Node *next;}Linkqueuenode;typedef struct {Linkqueuenode *front; Linkqueuenode *rear;/*分别定义队列的对首和对尾指针*/ }Linkqueue;typedef struct node /*定义栈结点类型*/{char data;struct node *next;}LinkStackNode,*LinkStack;void push( LinkStack top,char x) /*进栈*/{LinkStackNode *temp; /*创建新结点*/temp=(LinkStackNode *)malloc(sizeof(LinkStackNode));temp->data=x;temp->next=top->next;top->next=temp;}void getinmain() /*功能界面*/{printf("\n");printf(" 回文检测 \n");printf("\n\n");printf(" 1. 输入字符串 \n");printf(" 2. 检测是否为回文 \n");printf(" 3. 退出 \n");printf("\n请按指定的数字进行相应的操作:\n");}int queue(Linkqueue *q) /*初始化队列*/{q->front=(Linkqueuenode *)malloc(sizeof(Linkqueuenode));if(q->front!=NULL){q->rear=q->front;q->front->next=NULL;return 1;}else return 0;}int enter(Linkqueue *q,char x) /*入队操作*/{Linkqueuenode *newnode;newnode=(Linkqueuenode *)malloc(sizeof(Linkqueuenode));if(newnode!=NULL){newnode->data=x;newnode->next=NULL;q->rear->next=newnode;q->rear=newnode;return 1;}else return 0;}void pushenter(LinkStack top,Linkqueue *q) /*一个元素同时进栈和入队*/ {printf("请输入元素并以@结束\n");char x;/*进栈和入队的元素*/scanf("%c",&x);while(x!='@'){push(top,x);enter(q,x);scanf("%c",&x);}}void check(LinkStack top,Linkqueue *p){ /*检测是否为回文数*/ Linkqueuenode *q;LinkStack w;w=top->next;q=p->front->next;char a,b;int c=0;while(q!=NULL&&w->next!=NULL){a=w->data;b=q->next->data;q=q->next;w=w->next;printf("a=%c b=%c\n",a,b);if(a!=b)/*检测是否为回文数*/{c=1;printf("不是回文\n");break;}}if(c==0)printf("\n 是回文\n");}void main(){ LinkStackNode top;/*声明一个栈结点*/top.next=NULL;/*将栈顶值为空*/Linkqueue q;queue(&q);/*初始化队列*/system("pause");system("cls");s: getinmain();int b;scanf("%d",&b);switch(b){case 1:pushenter(&top,&q);system("pause");system("cls");goto s; case 2:check(&top,&q);system("pause");system("cls");goto s; case 3:exit(0);};}测试数据1.输入:12345654321@2.输入:msnfhydyhfnsm@3.输入:nf.v01210v.fn@4.输入:ablgj@5.输入:@。
堆栈判断回文实验报告
一、实验目的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. 模块之间关系及其相互调用的图示
数据结构实验报告(回文)
Boolean mark = true;
string str;
str = Console.ReadLine();
for (i = 0, j = str.Length - 1; i <= j; i++, j--)
{
if (str[i] != str[j])
mark = false;
break;
注:可根据实际情况加页
分析:第一次打开软件的时候,不知道打开何处,不同于以前都是打开窗体应用程序。“static void Main(string[] args)”
实现编程的见面,了解了编程的输入和输出的表达:Console.WriteLine("请输入一个字福串:");inputString =Console.ReadLine().Trim();Console.ReadLine();。
}
if (mark)
System.Console.WriteLine("你输入的是一个回文数!");
else System.Console.WriteLine("你输入的不是一个回文数!");
Console.ReadLine();
}
}
}
实验环境
计算机实验室,安装有VS电脑一台。
实验结果与
分析
运行以上的程序并输入一串代码得到如下的结果:
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
实验报告 回文判断
#define N 30//输入的最大数位大小
int Plalindrome()
{
SqStack L;
int i,amoun,c,d;
while((c = getchar())!='@'&&(amount<=N))
{
a[amount] = c;
}
if(i == amount)
return 1;
else
return 0;
}
void main()
{
int a;
a = Plalindrome();
if(a == 1)
cout<<"是回文"<<endl;
else
cout<<"不是回文"<<endl;
}
运行结果截屏:
回文判断判断回文数用指针判断回文回文数的判断判断是否为回文数判断字符串是否回文判断回文字符串c语言回文串判断回文诗回文数
实验报告
实验题目:写一个算法判断输入的一串以“@”为结束符的字符序列是否为回文。
sqstack.h :为实验指导书上的头文件(此处略);
main.cpp :主函数;
#include "sqstack.h"
amount++;
}
InitStack(L);//创建空栈
for(i=0;i<amount;i++)
{
Push(L,a[i]);//进栈
}
for(i=0;i<amount;i++)
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
.
数据结构实验报告判断回文数
级班:
内序号班:
名生姓学:
教师导指:
时间: 201124月年10日
一、实验目的'.
.
熟悉栈和队列的各项操作,区别栈和队列的操作原理。
二、实验内容
利用栈的操作完成读入的一个以*结尾的字符序列是否是回文序列的判断。
回文序列即正读与反读都一样的字符序列,例如:43211234*是回文序列,而789678*不是。
三、数据结构及算法思想
算法思想:从键盘上读取一个字符,同时存储在顺序栈与链队列之中,直到字符序列的最后一个字符为*停止插入。
在程序中设置了一个标志位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.模块之间关系及其相互调用的图示
'.
.
五、详细设计及运行结果(1)程序设计及编码
#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;
牰湩晴尨请输入由*结束且小于%d的回文序列:\n,MAX); for(i = 0;i<MAX+1;i++)
{
scanf(%c,&a[i]);
if(a[i] == '*')
break;
}
cnt = i;
牰湩晴尨输入了有%d个字符。
\n,cnt);
InitStack(&s);
InitQuene(&q);
for(i = 0;i<cnt;i++)
{
EnterQuene(&q,a[i],cnt);
Push(&s,a[i],cnt);
}
牰湩晴尨正序字符串为:\n);
for(i = 0;i<cnt+1;i++)
'.
.
{
DeleteQuene(&q,&b[i],cnt);
printf(%c,b[i]);
}
printf(\
);
牰湩晴尨逆序字符串为:\n);
for(i = 0;i<cnt+1;i++)
{
Pop(&s,&c[i]);
printf(%c,c[i]);
}
printf(\
);
for(i = 0;i<cnt+1;i++)
{
if(b[i] == c[i])
flag = 1;
else
{
flag = 0;
break;
}
}
if(flag)
牰湩晴尨此序列是回文序列!); else
牰湩晴尨此序列不是回文序列!); printf(\
);
}
(2)测试数据,运行结果
回文序列的输入:
回文序列的输出及判断:
'.
.
非回文序列的输入:
非回文序列的输出及判断:
六、调试情况,设计技巧及体会。
'.。