您的位置：360文档中心› 用栈和队列判断回文

用栈和队列判断回文

合集下载

数据结构回文实验报告

数据结构回文实验报告

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

实验报告——栈和队列的应用

实验报告——栈和队列的应用

实验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<iostream.h>#include<stdio.h>#include"ch3.h"template <class T>void LinkedQueue<T>::makeEmpty()//makeEmpty//函数的实现{LinkNode<T>*p;while(front!=NULL)//逐个删除队列中的结点{p=front;front=front->link;delete p;}};template <class T>bool LinkedQueue<T>::put_in(T&x）{//提交命令函数if(front==NULL){//判断是否为空front=rear=new LinkNode<T>;//如果为空，新结点为对头也为对尾front->data=rear->data=x;if(front==NULL) //分配结点失败return false;}else{rear->link=new LinkNode<T>;//如不为空，在链尾加新的结点rear->link->data=x;if(rear->link==NULL)return false;rear=rear->link;}return true;};template <class T>bool LinkedQueue<T>::carry_out()//执行命令函数{if(IsEmpty()==true)//判断是否为空{ return false; }cout<<front->data<<" ";//输出链尾的数据，代表执行打印命令LinkNode<T>*p=front;front=front->link;//删除以执行的命令，即对头修改delete p; //释放原结点return true;};void main() //主函数{LinkedQueue<char> q;//定义类对象char flag='Y'; //标志是否输入了命令const int max=30;//一次获取输入命令的最大个数while(flag=='Y') //循环{int i=0;char str[max]; //定义存储屏幕输入的命令的数组gets(str); //获取屏幕输入的命令while(str[i]!='\0'){q.put_in(str[i]);//调用提交命令函数，将每个命令存入队列中i++;}for(int j=0;j<=i;j++){if(q.IsEmpty()==true) //判断是否为空，为空则说明没有可执行的命令{cout<<"已经没有可执行的命令！是否继续输入命令(Y|N)?"<<endl;cin>>flag;continue; //为空跳出for循环为下次输入命令做好准备}q.carry_out();//调用执行命令的函数，将命令打印并删除}三、程序调试过程中所出现的错误无。

用栈实现回文判断的算法

用栈实现回文判断的算法

用栈实现回文判断的算法回文是指正读和反读都相同的字符串或序列，如"level"、"madam"等。

判断一个字符串是否为回文是编程中常见的问题，本文将介绍如何利用栈来实现这一功能。

栈是一种特殊的线性数据结构，具有后进先出（Last-In-First-Out，LIFO）的特点。

栈可以通过压栈（push）和弹栈（pop）操作来实现数据的存储和访问。

以字符串为例，我们可以通过将字符串中的每个字符依次入栈，然后再依次出栈，得到一个与原字符串相反的字符串。

如果这两个字符串相等，那么原字符串就是回文。

具体实现时，我们可以使用一个辅助栈来完成入栈和出栈操作。

首先，将原字符串的每个字符依次入栈，然后依次出栈并拼接到一个新的字符串中。

最后，将新的字符串与原字符串进行比较，如果相等，则原字符串是回文。

下面是用栈实现回文判断的算法的详细步骤：1. 创建一个空栈和一个空字符串。

2. 遍历原字符串的每个字符：- 将当前字符入栈。

3. 弹栈并将弹出的字符拼接到新字符串中，直到栈为空。

4. 将新字符串与原字符串进行比较：- 如果相等，则原字符串是回文；- 如果不相等，则原字符串不是回文。

下面是用栈实现回文判断的算法的Python代码实现：```pythondef is_palindrome(s):stack = []new_s = ""for c in s:stack.append(c)while stack:new_s += stack.pop()return new_s == s# 测试print(is_palindrome("level")) # 输出 Trueprint(is_palindrome("hello")) # 输出 False```通过上述算法的实现，我们可以用栈来判断一个字符串是否为回文。

算法的时间复杂度为O(n)，其中n是字符串的长度。

利用栈和队列判断字符是否是回文（C语言）

利用栈和队列判断字符是否是回文（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;}。

利用链式堆栈和队列实现回文判断范文

利用链式堆栈和队列实现回文判断范文
return 0;
}
*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)

数据结构回文判断

数据结构回文判断

数据结构回文判断数据结构回文判断引言在计算机科学中，数据结构是指组织和存储数据的方式，是计算机算法的基础。

回文是一个正读和反读都一样的字符串，常用来判断一个字符串是否具有对称性。

在本文档中，我们将探讨如何使用数据结构来判断一个字符串是否是回文。

回文判断算法回文判断算法的基本思想是将字符串分割为两部分，然后将其中一部分做翻转操作，最后将翻转后的结果与另一部分进行比较。

如果两部分相等，则该字符串是回文。

以下是一个使用栈和队列数据结构实现的回文判断算法的伪代码：```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. 弹出队列中的字符，并将其与原字符串中的字符进行比较。

数据结构用栈和队列判断回文数

数据结构用栈和队列判断回文数

数据结构⽤栈和队列判断回⽂数12321，你是不是你，这样的东西叫回⽂，由于队列和栈的存储⽅式不同，栈是LIFO，last in first out ,盘⼦⼀个⼀个堆，堆完后从上⾯开始拿；队列是FIFO，first in first out, 就像现实的排队。

将数字存进这两种结构中，逐⼀取出，如果相同，那就是回⽂数。

StackAndQueqe.h#include<stdio.h>typedef char DataType;typedef struct Node *PNode;struct Node{DataType info;PNode link;};typedef struct LinkQueqe *PQueqe;struct LinkQueqe{PNode f;PNode b;};typedef struct LinkStack *PStack;struct LinkStack{PNode top;};PStack createStack();int isEmptyStack(PStack pstack);void pushStack(PStack pstack,DataType element);DataType popStack(PStack pstack);DataType topStack(PStack pstack);void printStack(PStack pstack);PQueqe createQueqe();int isEmptyQueqe(PQueqe pqueqe);void pushQueqe(PQueqe pqueqe,DataType element);DataType popQueqe(PQueqe pqueqe);DataType topQueqe(PQueqe pqueqe);void printQueqe(PQueqe pqueqe);StackAndQueqe.c#include "StackAndQueqe.h"PQueqe createQueqe(){PQueqe pqueqe = (PQueqe)malloc(sizeof(struct LinkQueqe));if(pqueqe == NULL) printf("create fail");pqueqe ->f = NULL;pqueqe ->b = NULL;return pqueqe;}int isEmptyQueqe(PQueqe pqueqe){return (pqueqe ->f == NULL);}void pushQueqe(PQueqe pqueqe,DataType element){PNode p = (PNode)malloc(sizeof(struct Node));if(p == NULL) printf("nothing push");p ->info = element;p ->link = NULL;if(pqueqe ->f == NULL){pqueqe->f = p;//printf(" f %5d\n",pqueqe->f->info);}else pqueqe ->b ->link = p;pqueqe ->b = p;// printf("b %d\n",pqueqe->b->info);}DataType popQueqe(PQueqe pqueqe){PNode p;DataType temp;if(isEmptyQueqe(pqueqe)) printf("queqe is empty");p = pqueqe ->f;temp = p->info;pqueqe ->f = p->link;free(p);return temp;}DataType topQueqe(PQueqe pqueqe){if(pqueqe->f == NULL){printf("nothing top");return NULL;}return pqueqe -> f->info ;}void printQueqe(PQueqe pqueqe){PNode p = pqueqe ->f;if( isEmptyQueqe(pqueqe)){printf("nothing print");}while(pqueqe->f!= NULL){printf("%3c",pqueqe->f->info);pqueqe ->f = pqueqe ->f ->link;}pqueqe ->f = p;//此处的f随着link的变化变化最后需要还原回去！}PStack createStack(){PStack pstack = (PStack)malloc(sizeof(struct LinkStack));if(pstack == NULL) printf("create fail");pstack ->top = NULL;return pstack;}int isEmptyStack(PStack pstack){return(pstack->top == NULL);}void pushStack(PStack pstack,DataType element){PNode p = (PNode)malloc(sizeof(struct Node));if(p == NULL) printf("push fail");p ->info = element;p ->link = pstack ->top;pstack ->top = p;}DataType popStack(PStack pstack){PNode p;DataType temp;if(pstack ->top == NULL) printf("nothing pop");p = pstack ->top;temp = p->info;pstack ->top = pstack->top->link;free(p);return temp;}DataType topStack(PStack pstack){if(pstack ->top == NULL){printf("nothing pop");return NULL;}return pstack->top->info;}void printStack(PStack pstack){PNode p= pstack ->top;if(pstack ->top == NULL){printf("nothing pop");}while(pstack->top != NULL){printf("%3c",pstack ->top ->info);pstack ->top = pstack ->top ->link;}pstack ->top = p;}#include "StackAndQueqe.h"int main(){int i;char s[100];int n=0;PQueqe pqueqe ;PStack pstack;printf("please input string to judge whether it is a palindrome(回⽂数):\n"); scanf("%c",&s[0]);while(s[n]!='\n'){scanf("%c",&s[++n]);}printf(" the length is %d: \n",n);printf(" the string is : ");for(i=0;i<n;i++){printf("%c",s[i]);}pqueqe = createQueqe();for(i=0;i<n;i++){//printf("\n%c",s[i]);pushQueqe(pqueqe,s[i]);}pstack = createStack();for(i=0;i<n;i++){pushStack(pstack,s[i]);}printf(" \nthe queqe is : ");printQueqe(pqueqe);printf(" \nthe stack is : ");printStack(pstack);printf(" \n");for(i=0;i<n/2;i++){if(popQueqe(pqueqe)!= popStack(pstack)){printf("is not HUIWEN!\n");break;}else {printf("it is HUIWEN!\n");break;}}return 0;}简单的话只需要取出的数切半对⽐就⾏了。

回文判断的两种方法

回文判断的两种方法

回⽂判断的两种⽅法//想到两种⽅法，⼀是⽤栈把序列逆序对⽐，⼆是直接头尾对⽐字符串。

//问题：判断回⽂串如1223不是回⽂串，⽽1221是//思路1：分析以下回⽂的特点，会发现回⽂⽆论是正着读还是反着读都是⼀样的。

所以只要进⼀次栈，出⼀次栈，看进⼊序列是否⼀样就好了//思路2：直接判断前半段后半段对应位置是否相等。

有不等的就不是回⽂。

这个更简单些#include "stdio.h"#include "stdlib.h"#include "string.h"typedef struct stack{char data;stack *next;}stack;void Traversal(stack *p){ //遍历stack *q = p->next;while (q != NULL){printf("%C ",q->data);q = q->next;}}void init(stack *&s);int isEmpty(stack *s);void push(stack *&s,char x);int pop(stack *&s,char &x);//直接头尾对⽐判断回⽂// int huiwen(char *s,int n){ //回⽂返回0，⾮回⽂返回1// stack *c = (stack *)malloc(sizeof(stack));// c->next = NULL;// for(int i=0,j=n-1;i<=j;i++,j--){// if(s[i]!=s[j]) return 1; //数组版// }// return 0;// }//通过栈判断int huiwen(char *s,int n){ //参数：字符串s，字符串长度nstack *c = (stack *)malloc(sizeof(stack));c->next = NULL;for(int i=0;i<n;i++) push(c,s[i]);char a;for(int i=0;i<n;i++){pop(c,a);if(s[i] != a) return 1; //不是回⽂ //栈会把进栈序列逆序输出，如果输出序列等于字符串，那就是回⽂}return 0;}int main(){//string s="1221";char *str="ssccss";printf("%d",huiwen(str,6));getchar();return 0;}//注:在考试的时候直接调⽤函数就好了。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 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;
}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(){
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");
}运行结果如下图：
1．输入字符为回文字符
2．输入字符不是回文字符
三、编程并上机调试运行
四、时间、地点
五、指导教师
（在书写过程中若出现错误，望老师指出，谢谢）。

相关文档
最新文档