数据结构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语言队列-回文

数据结构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语言及程序设计》实践参考——回文数

《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.调试中遇到的问题及对问题的解决方法: 问题:程序出现未知错误。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 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)测试数据,运行结果
回文序列的输入:
回文序列的输出及判断:
'.
.
非回文序列的输入:
非回文序列的输出及判断:
六、调试情况,设计技巧及体会。

'.。

相关文档
最新文档