栈和队列实现回文
数据结构回文实验报告
数据结构回文实验报告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是字符串的长度。
实验二 栈和队列的基本操作实现及其应用
实验二栈和队列的基本操作实现及其应用一、实验目的1、熟练掌握栈和队列的基本操作在两种存储结构上的实现。
2、会用栈和队列解决简单的实际问题。
二、实验内容(可任选或全做)题目一、试写一个算法,判断依次读入的一个以@为结束符的字符序列,是否为回文。
所谓“回文“是指正向读和反向读都一样的一字符串,如“321123”或“ableelba”。
相关常量及结构定义:# define STACK_INIT_SIZE 100# define STACKINCREMENT 10# define OK 1# define ERROR 0typedef int SElemType;//栈类型定义typedef struct SqStack{ SElemType *base;SElemType *top;int stacksize;}SqStack;设计相关函数声明:判断函数:int IsReverse()栈:int InitStack(SqStack &S )int Push(SqStack &S, SElemType e )int Pop(SqStack &S,SElemType &e)int StackEmpty(s)题目二、编程模拟队列的管理,主要包括:出队列、入队、统计队列的长度、查找队列某个元素e、及输出队列中元素。
[实现提示]:参考教材循环队列的有关算法,其中后两个算法参考顺序表的实现。
题目三、RailsDescriptionThere is a famous railway station in PopPush City. Country there is incredibly hilly. The station was built in last century. Unfortunately, funds were extremely limited thattime. It was possible to establish only a surface track. Moreover, it turned out that the station could be only a dead-end one (see picture) and due to lack of available space it could have only one track.The local tradition is that every train arriving from the direction A continues in the direction B with coaches reorganized in some way. Assume that the train arriving from the direction A has N <= 1000 coaches numbered in increasing order 1, 2, ..., N. The chief for train reorganizations must know whether it is possible to marshal coaches continuing in the direction B so that their order will be a1, a2, ..., aN. Help him and write a program that decides whether it is possible to get the required order of coaches. You can assume that single coaches can be disconnected from the train before they enter the station and that they can move themselves until they are on the track in the direction B. You can also suppose that at any time there can be located as many coaches as necessary in the station. But once a coach has entered the station it cannot return to the track in the direction A and also once it has left the station in the direction B it cannot return back to the station.InputThe input consists of blocks of lines. Each block except the last describes one train and possibly more requirements for its reorganization. In the first line of the block there is the integer N described above. In each of the next lines of the block there is a permutation of 1, 2, ..., N. The last line of the block contains just 0.The last block consists of just one line containing 0.OutputThe output contains the lines corresponding to the lines with permutations in the input.A line of the output contains Yes if it is possible to marshal the coaches in the order required on the corresponding line of the input. Otherwise it contains No. In addition,there is one empty line after the lines corresponding to one block of the input. There is no line in the output corresponding to the last ``null'' block of the input. Sample Input51 2 3 4 55 4 1 2 366 5 4 3 2 1Sample OutputYesNoYes题目四、Sliding WindowDescriptionAn array of size n≤ 106 is given to you. There is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves rightwards by one position. Following is an example:The array is [1 3 -1 -3 5 3 6 7], and k is 3.Window position Minimum value Maximum value[1 3 -1] -3 5 3 6 7 -131 [3 -1 -3] 5 3 6 7 -331 3 [-1 -3 5] 3 6 7 -351 3 -1 [-3 5 3] 6 7 -351 3 -1 -3 [5 3 6] 7 361 3 -1 -3 5 [3 6 7]37Your task is to determine the maximum and minimum values in the sliding window at each position.InputThe input consists of two lines. The first line contains two integers n and k which are the lengths of the array and the sliding window. There are n integers in the second line.OutputThere are two lines in the output. The first line gives the minimum values in the window at each position, from left to right, respectively. The second line gives the maximum values.Sample Input8 31 3 -1 -3 5 3 6 7Sample Output-1 -3 -3 -3 3 33 3 5 5 6 7题目五(选作考查串知识)DNA Evolution【Description】Evolution is a seemingly random process which works in a way which resembles certain approaches we use to get approximate solutions to hard combinatorial problems. You are now to do something completely different.Given a DNA string S from the alphabet {A,C,G,T}, find the minimal number of copy operations needed to create another string T. You may reverse the strings you copy, and copy both from S and the pieces of your partial T. You may put these pieces together at any time. You may only copy contiguous parts of your partial T, and all copied strings must be used in your final T.Example: From S= “ACTG” create T= “GTACTAATAAT”1.Get GT......... by copying and reversing "TG" from S.2.Get GT AC... by copying "AC" from S.3.Get GTAC TA….. by copying "TA" from the partial T.4.Get GTACTA AT by copying and reversing "TA" from the partial T.5.Get GTACTAAT AAT by copying "AAT" from the partial T.【Input】The first line of input gives a single integer, 1 ≤k≤10, the number of test cases. Then follow, for each test case, a line with the string S , length of S is less then 19, and a line with the string T , length of T is less then 19.【Output】Output for each test case the number of copy operations needed to create T from S, or "impossible" if it cannot be done.【Sample Input】4ACGTTGCAACACGTTCGATCGAAAAAAAAAAAAAAAAAAAA【Sample output】1impossible46题目六(选作考查数组知识)Magic Squares描述Following the success of the magic cube, Mr. Rubik invented its planar version, called magic squares. This is a sheet composed of 8 equal-sized squares:1 2 3 48 7 6 5In this task we consider the version where each square has a different color. Colors are denoted by the first 8 positive integers. A sheet configuration is given by the sequence of colors obtained by reading the colors of the squares starting at the upper left corner and going in clockwise direction. For instance, the configuration of Figure 3 is given by the sequence (1,2,3,4,5,6,7,8). This configuration is the initial configuration.Three basic transformations, identified by the letters `A', `B' and `C', can be applied to a sheet:∙'A': exchange the top and bottom row,∙'B': single right circular shifting of the rectangle,∙'C': single clockwise rotation of the middle four squares.Below is a demonstration of applying the transformations to the initial squares given above:A:8 7 6 51 2 3 4B:4 1 2 35 8 7 6C:1 72 48 6 3 5All possible configurations are available using the three basic transformations.You are to write a program that computes a minimal sequence of basic transformations that transforms the initial configuration above to a specific target configuration.输入A single line with eight space-separated integers (a permutation of (1..8)) that are the target configuration.输出样例输入2 6 8 4 5 73 1样例输出7BCABCCB三、实验步骤㈠、数据结构与核心算法的设计描述㈡、函数调用及主函数设计(可用函数的调用关系图说明)㈢程序调试及运行结果分析㈣实验总结四、主要算法流程图及程序清单1、主要算法流程图:2、程序清单(程序过长,可附主要部分)//int IsReverse(){ ….while( (e=getchar())!='@'){e 依次入栈、入队 //push(S,e);EnQueue(Q,e);……..}While(!StackEmpty(S)) { pop(S,a);DeQueue(Q,b);If(a!=b) return 0;}return 1;}。
C语言用栈和队列实现的回文检测功能示例
C语⾔⽤栈和队列实现的回⽂检测功能⽰例本⽂实例讲述了C语⾔⽤栈和队列实现的回⽂功能。
分享给⼤家供⼤家参考,具体如下:#include<stdio.h>#include<malloc.h>//内存分配头⽂件#include<math.h>//在math.h中已定义OVERFLOW的值为3#define SIZE 100#define STACKINCREMENT 10#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0typedef int Status;typedef struct //栈的结构体{char a;} SElemType;typedef struct{SElemType *base;SElemType *top;int stacksize;} SqStack;typedef struct //QNode //队列的结构体{char b;struct QNode * next;} QNode,*QueuePtr;typedef struct // 链队列类型{QueuePtr front; // 队头指针QueuePtr rear; // 队尾指针} LinkQueue;//定义全局变量SqStack S;SElemType e;LinkQueue Q;QueuePtr p;char f;//栈操作Status InitStack(SqStack *S){S->base=(SElemType *)malloc(SIZE*sizeof(SElemType));if(!S->base) exit(OVERFLOW);S->top=S->base;S->stacksize=SIZE;return OK;}Status Push(SqStack *S,SElemType e){if(S->top-S->base>=S->stacksize){S->base=(SElemType *)malloc((S->stacksize+STACKINCREMENT)*sizeof(SElemType));if(!S->base) exit(OVERFLOW);S->top=S->base+S->stacksize;S->stacksize+=STACKINCREMENT;}*S->top++=e;return OK;}Status Stackempty(SqStack S)//栈是否为空{if(S.top==S.base)return TRUE;elsereturn FALSE;}Status Pop(SqStack *S,SElemType *e){if(S->top==S->base) return ERROR;*e=*--S->top;return OK;}Status StackLength(SqStack S)//求栈的长度{return (S.top-S.base);}//队列操作Status InitQueue(LinkQueue *Q){Q->front=(QueuePtr)malloc(sizeof(QNode));Q->rear=Q->front;if(!Q->front) exit(OVERFLOW);Q->front->next=NULL;return OK;}Status EnQueue(LinkQueue *Q,char f){p=(QueuePtr)malloc(sizeof(QNode));if(!p) exit(OVERFLOW);p->b=f;p->next=NULL;Q->rear->next=p;Q->rear=p;return OK;}Status DeQueue(LinkQueue *Q,char *f){if(Q->front==Q->rear) return ERROR;p=Q->front->next;*f=p->b;Q->front->next=p->next;if(Q->rear==p)Q->rear=Q->front;free(p);return OK;}Status QueueLength(LinkQueue Q){int i=0;p=Q.front;while(Q.rear!=p){i++;p=p->next;}return i;}Status QueueEmpty(LinkQueue Q){if(Q.front==Q.rear)return TRUE;elsereturn FALSE;}void main(){int i,m;char n,a[20];InitStack(&S);InitQueue(&Q);gets(a);for(i=0; a[i]!='&'; i++) /////////// &前的数据进栈{e.a=a[i];Push(&S,e);}for(i=i+1; a[i]!='\0'; i++) ////////// ‘ &'后的数据进⼊队列EnQueue(&Q,a[i]);if( StackLength(S)!=QueueLength(Q)) /////栈和队列的数据个数不⼀样 printf("NO");elsewhile(!Stackempty(S)&&!QueueEmpty(Q))///////栈和队列⾥还有数据 {Pop(&S,&e);m=e.a;DeQueue(&Q,&f);n=f;if(m!=n){printf("NO");break;}}if(m==n&&Stackempty(S)&&QueueEmpty(Q))printf("YES");}运⾏结果:希望本⽂所述对⼤家C语⾔程序设计有所帮助。
用栈和队列判断回文
⽤栈和队列判断回⽂⽤栈和队列判断回⽂栈和队列实验⼆⼀、实验⽬的1、掌握栈和队列的顺序存储结构和链式存储结构,以便在实际中灵活应⽤。
2、掌握栈和队列的特点,即后进先出和先进先出的原则。
3、掌握栈和队列的基本运算,如:⼊栈与出栈,⼊队与出队等运算在顺序存储结构和链式存储结构上的实现。
⼆、实验内容1(请简述栈的基本特性和栈的⼏种基本操作的机制栈是限定仅在表位进⾏插⼊或删除操作的线性表,栈的修改是按照后进先出的原则进⾏的,根据这种特性进⾏回⽂判断。
[问题描述]对于⼀个从键盘输⼊的字符串,判断其是否为回⽂。
回⽂即正反序相同。
如“abba”是回⽂,⽽“abab”不是回⽂。
[基本要求](1)数据从键盘读⼊;(2)输出要判断的字符串;(3)利⽤栈的基本操作对给定的字符串判断其是否是回⽂,若是则输出“该字符串是回⽂”,否则输出“该字符串不是回⽂”。
[测试数据]由学⽣任意指定。
2(设计简单的程序实现⽤栈判断回⽂#include#include#include#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef 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(){2SqStack 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");}运⾏结果如下图:31(输⼊字符为回⽂字符2(输⼊字符不是回⽂字符三、编程并上机调试运⾏四、时间、地点五、指导教师,在书写过程中若出现错误~望⽼师指出~谢谢, 4。
利用链式堆栈和队列实现回文判断范文
}
*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)
栈和队列实现回文
栈和队列的应用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. 弹出队列中的字符,并将其与原字符串中的字符进行比较。
数据结构用栈和队列判断回文数
数据结构⽤栈和队列判断回⽂数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;}简单的话只需要取出的数切半对⽐就⾏了。
数据结构C语言回文判断(运用栈以及队列完成)
数据结构实验报告回文判断班级:学号:学生姓名:指导教师:时间:2015年5月5日1.实验目的:熟悉栈和队列的各项操作,区别栈和队列的操作原理。
2.实验内容:利用栈的操作完成读入的一个以@结尾的字符序列是否是回文序列的判断.回文序列即正读与反读都一样的字符序列;例如:123&321@是;123&4321@、123&312@不是算法思想:从键盘上读取一个字符,同时存储在顺序栈与链队列之中,直到字符序列的最后一个字符为@停止输入,因为要满足特定的要求:序列1&序列2,故设置夜歌标记量falg=1,判断输入的元素个数是否为奇数个,若为偶数个则令flag=0,若为奇数个继续判断栈的中间元素是否为&,若不是则令flag=0,若是,将栈和队列中的元素依次出列,判断是否相等,若不相等则令flag=0,最后将flag的值返回给主函数,若flag被修改为0说明不是回文序列,否则反之!!判断回文序列的流程图:算法实现:(1)void InitStack(SeqStack *s):栈初始化模块,即初始化一个空栈,随后对该空栈进行数据的写入操作;(2)int push(SeqStack *s,char ch):入栈操作,即给空栈中写入数据;(3)int pop(SeqStack *s,char *x):出栈操作,即将栈中的数据输出,由于栈的操作是先进后出,因此,出栈的数据是原先输入数据的逆序;(4)void InitQuene(LinkQ *q):队列初始化,即初始化一个空队列,最后对该空队列进行数据的写入操作;(5)int enter(LinkQ *q,char ch):入队操作,即给空队列中写入数据;(6)int deleteq(LinkQ *q,char *c):出队操作,即将队列中的数据输出,由于队列的操作是先进先出,因此,出队的数据室原先输入数据的正序;(7)int huiwen(SeqStack s,LinkQ q):输入序列并判断所输入的序列是否是回文序列;(8)void main():主函数,用于调用前面的模块,并输出最终的判断结果。
用栈实现回文判断的算法
用栈实现回文判断的算法回文是指正读和反读都一样的字符串,例如"level"、"radar"等。
回文判断是计算机科学中的一个经典问题,也是算法学习中常见的一个练习题。
本文将介绍如何使用栈来实现回文判断的算法。
我们需要明确栈的概念。
栈是一种特殊的数据结构,它的特点是后进先出(Last-In-First-Out,LIFO)。
在栈中,我们只能在栈的顶部进行插入和删除操作。
这就意味着最后一个插入的元素将是第一个被删除的元素。
回文判断的思路是将字符串的每个字符依次入栈,然后再依次出栈与字符串的字符进行比较。
如果每一次出栈的字符与字符串对应位置的字符相等,那么这个字符串就是回文;如果有任何一次出栈的字符与字符串对应位置的字符不相等,那么这个字符串就不是回文。
接下来,我们来实现这个算法。
首先,我们需要定义一个栈的数据结构,并实现栈的入栈和出栈操作。
这里我们可以使用数组来实现栈。
```pythonclass Stack:def __init__(self):self.stack = []def push(self, item):self.stack.append(item)def pop(self):if not self.is_empty():return self.stack.pop()def is_empty(self):return len(self.stack) == 0```接下来,我们可以定义一个函数来判断一个字符串是否是回文。
首先,我们需要将字符串的每个字符入栈,然后再依次出栈与字符串的字符进行比较。
如果比较过程中有任何一个字符不相等,那么这个字符串就不是回文;如果全部字符比较完成后都相等,那么这个字符串就是回文。
```pythondef is_palindrome(string):stack = Stack()for char in string:stack.push(char)for char in string:if char != stack.pop():return Falsereturn True```我们可以测试一下这个算法的正确性。
回文问题
目录1.问题描述----------------------------------------------------------------------22.具体要求----------------------------------------------------------------------23.测试数据----------------------------------------------------------------------24.算法思想----------------------------------------------------------------------25.模块划分----------------------------------------------------------------------36.数据结构----------------------------------------------------------------------37.源程序------------------------------------------------------------------------48.测试情况--------------------------------------------------------------------149.设计总结--------------------------------------------------------------------1610.参考文献--------------------------------------------------------------------17课程设计报告1、问题描述找到一个文档中的回文单词并输出。
回文单词就是从左读到右和从右读到左是一样的,如:did、txt、eye等,其中文档中的内容有字母、数字和标点符号,回文单词的判断是不包含标点符号的,但文件输入流读取的时候标点也被一起读取进来了,因此要删除字符串中的标点符号,单独对每个单词进行判断。
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. 当输入不是回文字符串时,结果如下:六、总结反思拿到题目时,想到总体思路是让字符串正序和逆序比较。
数据结构C语言队列 回文
数据结构C语言队列回文数据结构c语言队列-回文实验课题一:回文(palindrome)是指一个字符串从前面读和从后面读都一样,仅使用若干栈和队列、栈和队列的adt函数以及若干个int类型和char类型的变量,设计一个算法来判断一个字符串是否为回文。
假设字符串从标准输入设备一次读入一个字符,算法的输出结果为true或者false。
可以用一些字符串测试输入结果,例如:\,\等#include#include#definem100typedefstruct{charstack[m];inttop;}stackstru;typedefstruct{charqueue[m];intfront;intrear;}queuestru;voidmain(){intstinit(stackstru*s);//初始化顺序栈intstempty(stackstru*s);//推论栈与否为空intstpush(stackstru*s,charx);//进栈charstpop(stackstru*s);//出栈intquinit(queuestru*q);//初始化循环队列intquempty(queuestru*q);//判断队列是否为空intenqueue(queuestru*q,chare);//入队chardequeue(queuestru*q);//出队charc;intflag=0;stackstru*s=(stackstru*)malloc(sizeof(stackstru));queuestru*q=(queuestru*)mall oc(sizeof(queuestru));stinit(s);quinit(q);printf(\while((c=getchar())!='!'){putchar(c);stpush(s,c);enqueue(q,c);}printf(\printf(\while(stempty(s)){if(stpop(s)==dequeue(q)){flag=1;continue;}else{flag=0;break;}}if(flag==1)printf(\elseprintf(\}intstinit(stackstru*s){s->top=0;return1;}//初始化栈intstempty(stackstru*s){if(s->top==0){return0;}else{return1;}}//推论栈与否空intstpush(stackstru*s,charx){if(s->top==m)//栈八十{printf(\return0;}else//栈未满{s->top=s->top+1;//栈顶科玄珠s->stack[s->top]=x;//字符进栈return1;} }//入栈操作charstpop(stackstru*s){chary;if(s->top==0)//栈为空{printf(\return'';//返回空格}else//栈不为空{y=s->stack[s->top];//取出栈顶元素s->top=s->top-1;//栈顶指示移动returny;}}//出栈操作方式intquinit(queuestru*q){q->front=0;q->rear=0;return1;}//初始化为一个觑的循环队列intquempty(queuestru*q){if(q->front==q->rear)//队头和队尾相等{return0;}else{return1;}}//判断队列是否为空intenqueue(queuestru*q,chare){if((q->rear+1)%m==q->front)//队列已八十{printf(\提示信息return0;}else{q->queue[q->rear]=e;//入队q->rear=(q->rear+1)%m;//移动队尾指针return1;}}//入队操作方式chardequeue(queuestru*q){charf;if(q->front==q->rear)//队列入空{printf(\//提示信息return0;}else{f=q->queue[q->front];//抽出队首元素q->front=(q->front+1)%m;//移动对头指针returnf;}}//出队操作。
回文
9 / 12
4-2
void push(Stack & s,char str) //入栈 { *s.top=str; ++s.top; } char pop(Stack & s,char &str) //出栈 { str=*--s.top; return str; }
10 / 12
tack s; //创建一个对象 ChuStack(s); //通过一个函数来初始化一个栈 SqQueue *q; // 创建一个列队的对象 InitQueue(q); //初始化一个列队 char a[CHARSIZE],str;//定义一个字符数组 int k,m,num=0; / /定义几个int型变量 cout<<"请输入一串字符串!"<<endl; cin>>a; k=strlen(a); //确定输入的字符的长度
22 / 12
实验结果
23 / 12
总结
通过此次任务,首先学会了队列和 栈的定义及其相关操作,其次了解栈和队 列区别,在次通过此次任务也加深了对上 次任务中的栈的理解,最后就是提升了自 我的编程能力与理解能力,在编程过程中 会遇到许多问题比如一开始所输入的字符 串中要用字符'#'来作为字符输入结束的标 志,最后查阅相关资料后解决了此问题。 总之,用数组的方法最简单,栈次之, 但是无论用哪种方法,其解题思路是不变 的。
03
3.1 3.2
对列
队列:另一种限定存取位置的线性表 特点:先进先出(First In/ Firs Out)),只用允许在表的一端插入,在另一端删除 对头(front):允许删除的一端
队尾(rear):允许插入的一端;
数据结构-回文序列判断
回文序列判断目录一、实验目的 (2)二、实验内容 (2)三、数据结构及算法思想 (2)四、模块划分 (2)1、对各个模块进行功能的描述 (2)2、模块之间关系及其相互调用的图示 (3)五、详细设计及运行结果 (3)1、设计源代码: (3)2、运行结果: (7)六、调试情况,设计技巧及体味 (7)1、熟悉并掌握栈的的创建、入栈和出栈等基本用法并能运用栈完成一些特定的任务。
2、熟悉并掌握队列的的创建、入队和出队等基本用法并能运用队列完成一些特定的任务。
3、运用栈和队列实现对“回文”序列的判断。
编写一个算法,判断一次读入一个以 @结束符的字母序列,是否为形如‘序列 1&序列2’模式的字符序列。
其中序列 1 和序列 2 中都不含字符‘&’。
且序列2 是序列 1 的逆序列。
例如,‘a+b&b+a’是属于该模式的字符序列,‘a+b&b-a’则不是。
运用栈和队列算法,在序列挨次输入时将序列分别入栈和入队列,利用栈FILO 和队列FIFO 的特点,通过出栈和出队列实现序列顺序和逆序的比较,根据题目描述的回文序列判断并输出结果。
本次设计共分为六个模块,分别是:初始化模块、输入模块、入栈模块、入队模块、判断模块、输出模块。
各个模块功能如下表。
模块功能描述初始化模块栈、队列等初始化输入模块字母序列输入入栈模块将输入序列入栈入队模块将输入序列入队判断模块将序列正、逆比较输出模块判断结果输出#include"stdio.h"#include"conio.h"#include"malloc.h" typedef struct NODE开始初始化模块入栈模块输入模块入队模块比较模块出栈出队列正、逆序判断输出模块结束{char data;struct NODE *next;}LinkStack;typedef struct Node{char data;struct Node *next;}LinkQueueNode;typedef struct{LinkQueueNode *front;LinkQueueNode *rear;}LinkQueue;void InitStack(LinkStack *top){top->next=NULL;}char Push(LinkStack *top,char a){LinkStack *temp;temp=(LinkStack *)malloc(sizeof(LinkStack));if(temp==NULL)return(0);temp->data=a;temp->next=top->next;top->next=temp;return(1);}char Pop(LinkStack *top){LinkStack *temp;char a;temp=top->next;if(temp==NULL)return(0);top->next=temp->next;a=temp->data;free(temp);return(a);}int LengthStack(LinkStack *top){LinkStack *temp;temp=top->next;while(temp!=NULL){count++;temp=temp->next;}return(count);}void InitQueue(LinkQueue *q){q->front=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));q->rear=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));q->rear=q->front;q->front->next=NULL;}char EnterQueue(LinkQueue *q,char a){LinkQueueNode *NewNode;NewNode=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));if(NewNode!=NULL){NewNode->data=a;NewNode->next=NULL;q->rear->next=NewNode;q->rear=NewNode;return(1);}elsereturn(0);}char OutQueue(LinkQueue *q){LinkQueueNode *temp;char a;if(q->rear==q->front)return(0);temp=q->front->next;q->front->next=temp->next;if(q->rear==temp)q->rear=q->front;a=temp->data;free(temp);}void main(){char a[100],flag1=0,flag2=0,n,m;int i=0,t=0;LinkStack *top=(LinkStack *)malloc(sizeof(LinkStack));LinkQueue *q=(LinkQueue *)malloc(sizeof(LinkQueue));InitStack(top);InitQueue(q);printf("please input a string end of @ :\n");while(a[i- 1]!=64){scanf("%c",&a[i]);i++;}for(t=0;t<i;t++){if(a[t]!=64){Push(top,a[t]);EnterQueue(q,a[t]);}}t=LengthStack(top);if(t%2==0)printf("Input wrong!");else{for(i=0;i<t;i++){n=Pop(top);m=OutQueue(q);if(n!=m)flag1=1;if((i==t/2)&&(n!=38))flag2=1;}if(flag1||flag2)printf("This is not palindrome sequence!");elseprintf("This is palindrome sequence!");}getch();}2.1、回文字符序列输入:2.2 非回文字符序列输入:通过这次数据结构试验,我学习了链栈的建立及其一些基本的操作方法和队列的建立及对其的一些基本操作,充分理解了栈和区别和联系,栈和队列都可以通过链表实现,区别在于对其操作的节点位置不同,更重要的是通过这次实践操作学会了完成一个设计的基本方法和步骤,拿到一个问题不能急于开始书写代码要将问题理清晰、找清思路、分好模块再开始敲代码,代码只是实现一个功能的工具,惟独好的解决问题的思路,才干做出好的程序。
队列与栈判断回文
1.用顺序表队列做回文判断#include<iostream>using namespace std;const int queueSize=50;typedef struct sqqueue{int data[50];int front,rear;}SqQueue;void InitQueue(SqQueue &sq) {sq.rear=sq.front=0;}int EnQueue(SqQueue &sq,int x) {if((sq.rear+1)%50==sq.front)return 0;sq.rear=(sq.rear+1)%50;sq.data[sq.rear]=x;return 1;}int DeQueue(SqQueue&sq,int &x) {if(sq.rear==sq.front)return 0;sq.front=(sq.front+1)%50;x=sq.data[sq.front];return 1;}int main(){bool Temp=true;SqQueue sq;int i,j,n,a[50],b[50];InitQueue(sq);cout<<"输入数字的个数:";cin>>n;cout<<"输入一段整形数字:";for(i=0;i<n;i++){cin>>a[i];EnQueue(sq,a[i]);}for(j=0;j<n;j++){DeQueue(sq,b[j]);}for(i=0;i<n;i++)if(a[n-i-1]!=b[i]){Temp=false;}if(Temp==true) cout<<"输入的文字回文";else cout<<"输入的文字不是回文";return 0;}2用链对做回文判断#include<iostream>using namespace std;typedef struct QNode{int data;struct QNode *next;}QType;typedef struct qptr{QType *front,*rear;}LinkQueue;void InitQueue(LinkQueue *&lq){lq=(LinkQueue *)malloc(sizeof(QType));lq->rear=lq->front=NULL;}void EnQueue(LinkQueue *&lq,int x){QType *s;s=(QType *)malloc(sizeof(QType));s->data=x;s->next=NULL;if(lq->front==NULL&&lq->rear==NULL)lq->rear=lq->front=s;else{lq->rear->next=s;lq->rear=s;}}int DeQueue(LinkQueue *&lq,int &x){QType *p;if(lq->front==NULL&&lq->rear==NULL) return 0;p=lq->front;x=p->data;if(lq->rear==lq->front)lq->rear=lq->front=NULL;elselq->front=lq->front->next;free(p);return 1;}int main(){LinkQueue *lq;InitQueue(lq);bool Temp=true;int i,j,n;int a[50],b[50];cout<<"请输入要判断文字的个数:";cin>>n;cout<<"输入要判断的文字:";for(i=0;i<n;i++){cin>>a[i];EnQueue(lq,a[i]);}for(i=0;i<n;i++){DeQueue(lq, b[i]);}for(j=0;j<n;j++)if(a[n-j-1]!=b[j]){Temp=false;}if(Temp==true)cout<<"输入的文字是回文\n";elsecout<<"输入的文字不是回文\n";return 0;}队列和栈#include<iostream.h>#include<string.h>#include<stdlib.h>//双栈数据结构定义typedef struct{int size;//栈的大小int length1;//栈1长度int length2;//栈2长度char *data;//数据}*PStack,Stack;//自定义类型错误信息enumStatus{ERROR_OK=0,ERROR_MEMORY_FALIED,ERROR_STACK_ERROR,ERROR_OK_ YES,ERROR_OK_NO};void GetErrorMsg(const Status errCode)//显示错误信息{char strMsg[256];switch(errCode){case ERROR_OK:strcpy(strMsg,"执行成功!");break;case ERROR_MEMORY_FALIED:strcpy(strMsg,"内存分配错误!");break;case ERROR_STACK_ERROR:strcpy(strMsg,"数据错误!");break;case ERROR_OK_YES:strcpy(strMsg,"判断成功:结果是回文!");break;case ERROR_OK_NO:strcpy(strMsg,"判断成功:结果不是回文!");break;default:strcpy(strMsg,"Unknown Error !");break;}cout<<strMsg<<endl;}Status CreateStack(PStack&pst,char*str)//根据相应的字符串创建栈{pst=new Stack;if(pst==NULL)//创建栈失败返回return ERROR_MEMORY_FALIED;pst->length1=0;pst->length2=0;pst->size=strlen(str)+1;pst->data=new char[pst->size];//分配数据空间::memset(pst->data,0,strlen(str));//初始栈内数据if(pst->data==NULL)//空间分配失败返回{return ERROR_MEMORY_FALIED;}char *pTemp,*qTemp;pTemp=str;qTemp=str;qTemp+=strlen(str)-1;//将指针移到字符串尾int i=0;while(pTemp<=qTemp)//将字符串中的字符压入双栈{pst->data[i]=*pTemp;pst->data[pst->size-i]=*qTemp;pst->length1++;pst->length2++;i++;pTemp++;qTemp--;}return ERROR_OK;}Status GetResult(const PStack&pst)//获取结果{if(pst->length1!=pst->length2||pst==NULL){return ERROR_STACK_ERROR;}//如果数据有误返回while(pst->length1!=0)//依次取出栈中元素比较{if(pst->data[--pst->length1]!=pst->data[pst->size-(--pst->length2)]) return ERROR_OK_NO;//如果不相等返回ERROR_OK_NO}return ERROR_OK_YES;}void main(){PStack pst;char str[256];cout<<"******************************************"<<endl <<"************欢迎使用回文判断程序**********"<<endl<<"******************************************"<<endl;cout<<"Pelease Enter A String:";cin>>str;if(ERROR_OK==CreateStack(pst,str)){GetErrorMsg(GetResult(pst));}system("pause");}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
栈和队列的应用
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;
else
ss=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;
}。