用栈和队列判断回文
数据结构回文实验报告
数据结构回文实验报告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 输出判断结果根据比较结果，输出判断字符串是否为回文。
回文字符的判断(栈与队列)代码
//头文件//code.h#define TRUE 1#define FALSE 0#define ok 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define NULL 0typedef int Status;//主函数//test.cpp#include"code.h"#include<stdlib.h>#include<process.h>#include<stdio.h>#include<String.h>#define STACK_SIZE 100 /* 栈初始向量大小 */ #define STACKINCREMENT 10//*************队列的操作函数*******************typedef char QElemType;typedef struct QNode{QElemType data;struct QNode *next;}QNode,*QueuePtr;typedef struct {QueuePtr front; //队首QueuePtr rear; //队尾}LinkQueue;Status InitQueue(LinkQueue &Q){ //构造空队列Q.front=Q.rear =(QueuePtr)malloc(sizeof(QNode));if(!Q.front) exit(OVERFLOW);Q.front->next=NULL;return ok;}Status DestoryQueue(LinkQueue &Q){ //销毁队列while(Q.front ){Q.rear=Q.front->next;free(Q.front);Q.front=Q.rear;}return ok;}Status EnQueue (LinkQueue &Q,QElemType e){ //在队尾插入元素QNode *p;p=(QueuePtr)malloc(sizeof(QNode));if(!p) exit (OVERFLOW);p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;return ok;}Status DeQueue(LinkQueue &Q,QElemType&e){ //删除队首元素，并返回其值if(Q.front==Q.rear) return ERROR;QNode *p;p=Q.front->next;e=p->data;Q.front->next=p->next;if(Q.rear==p) Q.rear=Q.front;free(p);return ok;}//**************************栈的操作函数**************************typedef char ElemType;typedef struct SqStack{ElemType *base; /* 栈不存在时值为NULL */ElemType *top; /* 栈顶指针 */ int stacksize ; // 当前已分配空间，以元素为单位}SqStack ;Status InitStack(SqStack &s){ /*构造空栈s*/ElemType *a=(ElemType *)malloc(10*sizeof(ElemType));realloc(a,STACK_SIZE *sizeof(ElemType));s.base=(ElemType *)malloc(STACK_SIZE *sizeof(ElemType));if (! s.base) return ERROR; //存储分配失败s.top=s.base ; /* 栈空时栈顶和栈底指针相同 */ s.stacksize=STACK_SIZE;return ok ;}Status GetTop(SqStack S,ElemType &e){ //返回栈顶元素if(S.top==S.base) return ERROR;e=*(S.top-1);return ok;}Status push(SqStack &S,ElemType e){ //进栈if (S.top-S.base>=S.stacksize) return ERROR;*S.top=e;S.top++ ; /* 栈顶指针加1，e成为新的栈顶 */return ok;}Status pop( SqStack &S, ElemType &e ){ //出栈if ( S.top== S.base ) return ERROR ; /* 栈空，返回失败标志 */ S.top-- ;e=*S.top ;return ok ;}int stackLength( SqStack S){ //栈的长度return S.top-S.base ;}Status StackEmpty( SqStack &S){ //判断栈是否为空if ( S.top== S.base ) return TRUE;else return FALSE;}//**************************比较函数********************int compare(){SqStack T;LinkQueue R;InitStack(T);InitQueue(R);char ch;char a,b;printf("请输入要判断的字符串以@作为结束符\n");while((ch=getchar())!='@'){push(T,ch); //进栈EnQueue(R,ch); //入队}while(T.top!=T.base){pop(T,a); //出栈DeQueue(R,b); //出队if(a!=b) return ERROR; //比较字符是否相同else return ok;}}//*******************主函数***************************void main(){int r=compare();if(r==1)printf("%s","此为回文字符序列\n");elseprintf("%s","此不为回文字符序列\n");}。
利用栈和队列判断字符是否是回文（C语言）
利⽤栈和队列判断字符是否是回⽂（C语⾔）// File Name: palindrome.h//// Destination:利⽤栈和队列判断字符串是否是回⽂//#ifndef PALINDROME#define PALINDROME#include <stdio.h>// 链式队列结构的定义typedef char ElemType;typedef struct Node{char data; // 元素数据struct Node *next;// 链式队列中结点元素的指针}QNode,*QueuePtr;typedef struct{QueuePtr front;// 队列头指针QueuePtr rear;// 队列尾指针}LinkQueue;// 栈结构的定义typedef struct Stack{ElemType *base;ElemType *top;int stacksize;}SqStack;// 链式队列的基本操作bool InitQueue(LinkQueue *Q);bool EnQueue(LinkQueue *Q, ElemType e);bool DeQueue(LinkQueue *Q, ElemType *e);// 栈的基本操作bool InitStack(SqStack *S);bool Push(SqStack *S, ElemType e);bool Pop(SqStack *S, ElemType *e);#endif// File Name: palindrome.cpp//// Destination:利⽤栈和队列判断字符串是否是回⽂#include <stdlib.h>#include <malloc.h>#include "palindrome.h"const int STACK_INIT_SIZE = 100; // 初始分配的长度const int STACKINCREMENT = 10; // 分配内存的增量//操作⽬的：初始化队列//初始条件：⽆//操作结果：构造⼀个空的队列//函数参数：//LinkQueue *Q 待初始化的队列//返回值：// bool 操作是否成功------------------------------------------------------------*/bool InitQueue(LinkQueue *Q){Q->front = Q->rear = (QueuePtr)malloc(sizeof (QNode)); if (!Q->front){exit(0);}Q->front->next = NULL;return true;}//操作⽬的：在队列末尾插⼊元素e//初始条件：队列Q已存在//操作结果：插⼊元素e作为队列新的尾结点//函数参数：//LinkQueue *Q 队列Q//ElemType e 待插⼊的数据元素//返回值：//bool 操作是否成功bool EnQueue(LinkQueue *Q, ElemType e){QueuePtr p = (QueuePtr)malloc(sizeof(QNode));if (!p){exit(0);}p->data = e;p->next = NULL;Q->rear->next = p;Q->rear = p;return true;}//操作⽬的：删除链式队列的头结点//初始条件：队列Q已存在//操作结果：删除链式队列的头结点//函数参数：//LinkQueue *Q 队列Q//ElemType *e 待插⼊的数据元素//返回值：//bool 操作是否成功bool DeQueue(LinkQueue *Q, ElemType *e){if (Q->front == Q->rear) //空队列{return false;}QueuePtr p = Q->front->next;//p指向头结点的下个位置 *e = p->data;Q->front->next = p->next;if (Q->rear == p){Q->rear = Q->front;}free(p);return true;}//操作⽬的：初始化栈//初始条件：⽆//操作结果：构造⼀个空的栈//函数参数：// SqStack *S 待初始化的栈//返回值：// bool 操作是否成功bool InitStack(SqStack *S){S->base = (ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType));if (S->base == NULL){return false;}S->top = S->base;S->stacksize = STACK_INIT_SIZE;return true;}//操作⽬的：压栈——插⼊元素e为新的栈顶元素//初始条件：栈S已存在//操作结果：插⼊数据元素e作为新的栈顶//函数参数：//SqStack *S 栈S//ElemType e 待插⼊的数据元素//返回值：// bool 操作是否成功bool Push(SqStack *S, ElemType e){if (S->top - S->base >= S->stacksize){S->base = (ElemType *)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(ElemType)); if (!S->base){return false;}S->top = S->base + S->stacksize;S->stacksize += STACKINCREMENT;}*(S->top++) = e;return true;}//操作⽬的：弹栈——删除栈顶元素//初始条件：栈S已存在且⾮空//操作结果：删除S的栈顶元素，并⽤e返回其值//函数参数：//SqStack *S 栈S//ElemType *e 被删除的数据元素值//返回值：//bool 操作是否成功bool Pop(SqStack *S, ElemType *e){if (S->top == S->base)return false;*e = (*--S->top);return true;}// 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;}。
回文数据结构
判断是否为回文实验报告信息系日期姓名学号 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.当输入的不是回文的时候，结果如下八、总结。
利用链式堆栈和队列实现回文判断范文
}
*d=p->data;
}
7：撤销堆栈：
void Destory(StNode *head)
{
StNode *p,*p1;
p=head;
while(p!=NULL)
{
p1=p;
p=p->next;
free(p1);
}
}
2、把对队列的创建及操作函数放到LQueue头文件下：
1：头结点结构体的创建：
二、实验目的
熟练运用堆栈和队列的各种操作，并会运用他们的特点做一些实际的应用。
二、实验步骤：
1、把堆栈的创建及操作函数放到LStack头文件下：
1：定义节点结构体：
typedef struct snode
{
DataType data;
struct snode *next;
}StNode;
2：初始化堆栈：
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<windows.h>
typedef int DataType;
#include"SLNode.h"
#include"Stack.h"
void main()
{
SLNode *la,*lb;
return 0;
}
p->data=x;
p->next=head->next;
head->next=p;
return 1;
}
5：出栈函数：
int StackPop(StNode *head,DataType *d)
数据结构课程设计回文数问题
湖南科技学院课程设计报告课程名称：数据结构课程设计课程设计题目：02、回文问题系：专业：年级、班：姓名：学号：指导教师：职称：2011年12月目录1.问题描述----------------------------------------------------------------------32.具体要求----------------------------------------------------------------------33.测试数据----------------------------------------------------------------------34.算法思想----------------------------------------------------------------------35.模块划分----------------------------------------------------------------------46.数据结构----------------------------------------------------------------------47.源程序------------------------------------------------------------------------78.测试情况--------------------------------------------------------------------149.设计总结--------------------------------------------------------------------1410.参考文献--------------------------------------------------------------------15一、问题描述利用栈跟队列找出一个TXT文档中所有的回文单词并输出。
栈和队列实现回文
栈和队列的应用1.题目要求：输入一段字符串，判断字符串是否是回文。
回文字符串的定义：字符串的顺序输入和逆序输出内容完全一样。
要求出入一段字符串，以‘#’为结束符；判断是否是回文，并输出；2.实验目的：通过做回文的题，来熟悉栈和队列的结构以及内容，最终达到掌握3.实验步骤1.定义栈的结构体：typedef struct { //栈结构的定义int *top;int *base;int stacksize;}sqstack;2.定义队列的结构体：typedef struct queue{ //队列的结构体定义int data;struct queue *next;}queue,*que;typedef struct {que front; //队列的头指针que rear; //队列的尾指针}Q;4.相关函数：void inistack(sqstack &s)//初始化一个空栈bool just(sqstack &s)//判断栈是否为空，返回bool类型void push(sqstack &s,int e)//入栈char pop(sqstack &s,int &e)//出栈，返回char类型void initQ(Q &q)//初始化一个空队列pushq(Q &q,int e)//入队char popq(Q &q,int &e)//出队，返回char类型5.总体结构图6.运行结果分析完成对字符串的判断以及输出；7.程序清单#include<iostream.h>#include<malloc.h>typedef struct { //栈结构的定义int *top;int *base;int stacksize;}sqstack;void inistack(sqstack &s)//初始化一个空栈{s.base=(int *)malloc(100*sizeof(sqstack));if(!s.base){cout<<"分配失败"<<endl;}s.top=s.base;s.stacksize=100;}bool just(sqstack &s){bool ss=true;if(s.top==s.base)ss=false;elsess=true;return ss;}void push(sqstack &s,int e)//入栈{if(s.top-s.base>=s.stacksize){s.base=(int *)realloc(s.base,(s.stacksize+10)*sizeof(sqstack));s.top=s.base+s.stacksize;s.stacksize+=10;}*s.top++=e;}char pop(sqstack &s,int &e)//出栈{if(s.base==s.top){cout<<"栈已经为空"<<endl;}e=*--s.top;}typedef struct queue{ //队列的结构体定义int data;struct queue *next;}queue,*que;typedef struct {que front;que rear;}Q;void initQ(Q &q)//初始化一个空队列{q.front=q.rear=(queue *)malloc(sizeof(queue));if(!q.front){cout<<"分配失败"<<endl;}q.front->next=NULL;}void pushq(Q &q,int e)//入队{queue *p;p=(queue *)malloc(sizeof(queue));p->data=e;p->next=NULL;q.rear->next=p;q.rear=p;}char popq(Q &q,int &e)//出队{queue *t;if(q.front==q.rear){cout<<"队列已经为空"<<endl;}t=(queue *)malloc(sizeof(queue));t=q.front->next;e=t->data;q.front->next=t->next;if(q.rear==t)q.rear=q.front;delete t;return e;}{char ch;int e,k;bool ss=true;sqstack s;Q q;inistack(s);initQ(q);cout<<"输入字符以‘#’为结束符："<<endl;cin>>ch;while(ch!='#'){push(s,ch);pushq(q,ch);cin>>ch;}while(just(s)){pop(s,e);popq(q,k);if(e!=k){cout<<"该字符串不是回文"<<endl;ss=false;break;}}if(ss){cout<<"该字符串是回文"<<endl;}cout<<endl;}。
数据结构回文判断
数据结构回文判断数据结构回文判断引言在计算机科学中，数据结构是指组织和存储数据的方式，是计算机算法的基础。
回文是一个正读和反读都一样的字符串，常用来判断一个字符串是否具有对称性。
在本文档中，我们将探讨如何使用数据结构来判断一个字符串是否是回文。
回文判断算法回文判断算法的基本思想是将字符串分割为两部分，然后将其中一部分做翻转操作，最后将翻转后的结果与另一部分进行比较。
如果两部分相等，则该字符串是回文。
以下是一个使用栈和队列数据结构实现的回文判断算法的伪代码：```function isPalindrome(string):stack = createStack()queue = createQueue()for char in string:stack.push(char)queue.enqueue(char)while stack.isNotEmpty() and queue.isNotEmpty():if stack.pop() != queue.dequeue():return Falsereturn True```如何使用数据结构进行回文判断栈（Stack）栈是一种后进先出（LIFO）的数据结构，它可以用来将元素依次压入栈中，并按照相反的顺序弹出。
在回文判断算法中，我们可以使用栈来实现将字符串逆序操作。
以下是使用栈实现回文判断的步骤：1. 创建一个空栈。
2. 将字符串的每个字符依次压栈。
3. 弹出栈中的字符，并将其与原字符串中的字符进行比较。
如果不相等，则该字符串不是回文。
4. 如果栈为空，且所有字符都相等，则该字符串是回文。
队列（Queue）队列是一种先进先出（FIFO）的数据结构，它可以用来将元素依次入队，并按照相同的顺序出队。
在回文判断算法中，我们可以使用队列来实现将字符串正序操作。
以下是使用队列实现回文判断的步骤：1. 创建一个空队列。
2. 将字符串的每个字符依次入队。
3. 弹出队列中的字符，并将其与原字符串中的字符进行比较。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
用栈和队列判断回文
栈和队列实验二
一、实验目的
1、掌握栈和队列的顺序存储结构和链式存储结构，以便在实际中灵活应用。
2、掌握栈和队列的特点，即后进先出和先进先出的原则。
3、掌握栈和队列的基本运算，如:入栈与出栈，入队与出队
等运算在顺序存储结构和链式存储结构上的实现。
二、实验内容
1(请简述栈的基本特性和栈的几种基本操作的机制
栈是限定仅在表位进行插入或删除操作的线性表，栈的修改是按照后进先出的原则进行的，根据这种特性进行回文判断。
[问题描述]
对于一个从键盘输入的字符串，判断其是否为回文。
回文即正反序相同。
如“abba”是回文，而“abab”不是回文。
[基本要求]
(1)数据从键盘读入;
(2)输出要判断的字符串;
(3)利用栈的基本操作对给定的字符串判断其是否是回文，
若是则输出“该字符串是回文”，否则输出“该字符串不是
回文”。
[测试数据]
由学生任意指定。
2(设计简单的程序实现用栈判断回文
#include<stdio.h>
#include <stdlib.h>
#include <string.h>
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef struct{
char *base;
char *top;
int stacksize;
1
}SqStack;
void InitStack(SqStack &S){
S.base =(char *)malloc(STACK_INIT_SIZE * sizeof(char));
if(!S.base)exit(0);
S.top = S.base;
S.stacksize = STACK_INIT_SIZE;}
void Push(SqStack &S,char e){
if(S.top - S.base >= S.stacksize){
S.base = (char *) realloc (S.base,(S.stacksize + STACKINCREMENT) * sizeof(char));
if(!S.base) printf("存储分配失败～");
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
}
*S.top++ = e;
}
char Pop(SqStack &S,char &e){
if(S.top == S.base) {
printf("该栈为空!");
printf("\n");
e = 'E';
}else{
e = *--S.top;
}
return e;
}
void main(){
2
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 g = 0; //定义一个计数器
for(int w = 0;w < k;w++){
char x = Pop(S,e);
printf("%c",x);
if(a[w] == x){//比较数组中的第w个值与栈中返回的第w个值是否相等g++; //若相等的话，计数器加一
}
}
printf("\n");
if(g == k){ //判断计数器的值与输入的数值是否相等
printf("YES");//相等的话打印出YES
}else{
printf("NO");//否则打印出NO
}
printf("\n");
}运行结果如下图:
3
1(输入字符为回文字符
2(输入字符不是回文字符
三、编程并上机调试运行
四、时间、地点
五、指导教师
,在书写过程中若出现错误～望老师指出～谢谢, 4。