回文判断实验二

合集下载

回文判断实验二

回文判断实验二

回文判断实验二洛阳理工学院实验报告系别计算机系班级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个字符。

java实验报告回文数

java实验报告回文数
}
else
{
System.out.printf("\t%d不是回文数", number);
}
}
else if (【代码6】) //判断number是4位数的条件
{
System.out.printf("\n%d是4位数",number);
If (【代码7】) //判断number是回文数的条件码
{
System.out.printf("\t%d是回文数", number);
32567位数32567不是回文数6实验总结及心得这次实验使我对java程序的编写有了更进一步的了解熟悉掌握了ifelseif多分支语句的运用
《Java程序设计》实验报告
实验二:回文数
专业班级:通信工程2008级1班
姓名:
学号:
时间:
实验二:回文数
1、实验目的:
让学生掌握if-else if多分支语ຫໍສະໝຸດ 。}else{
System.out.printf("\t%d不是回文数", number);
}
}
else if(d2!=0)
{
System.out.printf("\n%d是2位数", number);
if(d1==d2)
{
System.out.printf("\t%d是回文数", number);
}
if(number<=99999&&number>=1)
{
d5=number/10000;
d4=number%10000/1000;
d3=number%1000/100;

回文判断实验报告

回文判断实验报告

回文判断实验报告一(实验题目:回文判断二(实验目的:对于一个从键盘输入的字符串,判断其是否为回文。

回文即正反序相同。

如“abba”是回文,而“abab”不是回文。

三(实验需求:1.数据从键盘读入;2.输出要判断的字符串;3.利用栈的基本操作对给定的字符串判断其是否是回文,若是则输出“Yes”否则输出“No”四(主要实现函数(1)建立顺序栈存储结构typedef struct { }(2)初始化int initstack(Sqstack &s,int maxsize)(3)入栈int enstack(Sqstack &s, char e) (4)出栈int popstack(Sqstack &s,char &e)(5)判断是否为回文int main(){int r; //用于判断是否为回文Sqstack L,Q; //定义两个栈initstack(L,20);initstack(Q,20);int l; //用于记录输入字符的长度 cout<<"请输入字符串长度"; cin>>l;if(l<=0)exit(1);cout<<"输入字符"<<endl;for(int i=1;i<=l;i++) //输入字符 {char p;cin>>p;enstack(L,p); //入栈 L }cout<<endl;for(int m=1;m<=l;m++){char f;f=getstack(L,m); //从栈 L中取元素,在入栈 Qenstack(Q,f);}for(int n=1;n<=l;n++){char a,b; //从栈 L Q 出栈,比较popstack(L,a);popstack(Q,b);if(a!=b)r=1;else r=2;}if(r==1)cout<<"no"<<endl<<endl;五(源程序#include <iostream> using namespace std; typedef char SElemType; typedef struct {SElemType *base;SElemType *top;int stacksize;}Sqstack;int initstack(Sqstack &s,int maxsize) /{s.base=new SElemType[maxsize]; if(!s.base)exit(1);s.top=s.base;s.stacksize=maxsize;return 0;}int enstack(Sqstack &s, char e){if(s.top-s.base==s.stacksize)exit(1); *s.top=e;s.top++;return 0;}int popstack(Sqstack &s,char &e){if(s.top==s.base)exit(1);e=*--s.top;return 0;}int getstack(Sqstack &s,int i) { SElemType *p;p=s.top;for(int j=1;j<=i;j++){p--;}return *p;}int main(){int r; Sqstack L,Q; initstack(L,20); initstack(Q,20);int l; cout<<"请输入字符串长度"; cin>>l;if(l<=0)exit(1);cout<<"输入字符"<<endl;for(int i=1;i<=l;i++) {char p;cin>>p;enstack(L,p); }cout<<endl;for(int m=1;m<=l;m++){char f;f=getstack(L,m);enstack(Q,f);}for(int n=1;n<=l;n++){char a,b;popstack(L,a);popstack(Q,b);if(a!=b)r=1;else r=2;}if(r==1)cout<<"no"<<endl<<endl; else if(r==2)cout<<"yes"<<endl<<endl; else cout<<"发生错误"<<endl;cout<<"继续判断输入Y,退出输入N"<<endl;char d;cin>>d;if(d=='y'||d=='Y')main();else return 0;}五(各功能的运行界面:(1)主界面:(2)输入1,2,3,4四个字符判断是否是回文,运行界面如下:(3)设置字符串长度为5,a,s,d,s,a,判断是否为回文,运行界面如下:。

数据结构回文实验报告

数据结构回文实验报告

数据结构回文实验报告数据结构回文实验报告引言:数据结构是计算机科学中的重要概念,它研究如何组织和管理数据,以便高效地访问和操作。

回文是一种特殊的字符串,它正着读和倒着读都一样。

在本实验中,我们将探索使用不同的数据结构来判断一个字符串是否为回文。

实验目的:1. 了解回文的概念和特点;2. 掌握常见的数据结构,如数组、链表和栈;3. 实践使用不同数据结构来判断字符串是否为回文;4. 比较不同数据结构在回文判断中的性能差异。

实验过程:首先,我们需要定义一个字符串,并将其存储在不同的数据结构中。

我们选择了“level”这个回文字符串作为示例。

1. 数组:我们使用一个字符数组来存储字符串。

首先,我们需要计算字符串的长度,并将每个字符按顺序存储在数组中。

然后,我们使用两个指针,一个指向数组的开头,一个指向数组的末尾,逐个比较它们所指向的字符是否相同。

如果所有字符都相同,则该字符串是回文。

2. 链表:我们使用一个单向链表来存储字符串。

每个节点包含一个字符和一个指向下一个节点的指针。

我们将字符串的每个字符依次插入链表的末尾。

然后,我们使用两个指针,一个指向链表的开头,一个指向链表的末尾,逐个比较它们所指向的字符是否相同。

如果所有字符都相同,则该字符串是回文。

3. 栈:我们使用一个栈来存储字符串。

我们将字符串的每个字符依次入栈。

然后,我们使用两个指针,一个指向栈的顶部,一个指向栈的底部,逐个比较它们所指向的字符是否相同。

如果所有字符都相同,则该字符串是回文。

实验结果:我们对以上三种数据结构进行了回文判断实验,并记录了结果。

在本次实验中,我们发现使用数组和栈的方法可以正确判断字符串是否为回文,而使用链表的方法则无法正确判断。

这是因为链表无法像数组和栈一样快速访问和比较元素。

性能比较:我们进一步比较了使用数组和栈的方法在回文判断中的性能差异。

我们使用了不同长度的字符串进行实验,并记录了执行时间。

实验结果显示,数组的执行时间与字符串长度成正比,而栈的执行时间与字符串长度无关。

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

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

回文判断

回文判断

设计题目<二>: 3.4.4回文判断P591.设计要求1.1问题描述试写一个算法,判断依次读入的一个以@为结束符的字母序列,是否为形如“序列1&序列2”模式的字符序列。

其中序列1和序列2中都不含字符“&”,且序列2是序列1的逆序列。

例如:“a+b&b+a”是属该模式的字符序列,而“1+3&3-1”则不是。

1.2需求分析这是一个利用栈结构完成的程序。

为了实现算术优先算法,我们使用两个工作栈,一个称为操作符栈(OPTR),用以寄存运算符;一个称为操作数栈(OPND),用以寄存操作数或运算结果。

算法的基本思想是:(1)输入测试数据组数,接着分组输入字符串,以@结尾。

(2)输入序列总长不超过(MAX_N = 10005)/2个。

将序列1先入栈,接着处理序列2,同时出栈判断。

(3)将序列1全部入栈,接着输入序列2,同时出栈判断。

(4)如果序列满足题目要求,则输出“回文序列”;否则,输出“非回文序列”。

(5)测试数据:qwer&rewq@qwerrewq@qwer&rewq12364&23131@2. 概要设计2.1主界面设计回文判断的程序界面设计并不复杂,有提示字符串输入及结束符号的信息即可。

运行界面如下图所示:图2.12.2数据结构本系统采用顺序栈结构类型(stack)存储用户输入的字符串以便判断是否为回文。

typedef struct{char elem[Stack_Size]; //用来存放栈中元素的一维数组int top; //用来存放栈顶元素的下标}SeqStack; 使用结构体,内部定义数组模拟栈。

top为栈顶指针,指向当前元素的下一个位置。

3 模块设计3.1模块设计:本程序包含3个模块:主程序模块,判断模块,和顺序栈操作模块,调用关系如下:主程序回文判断模块顺序栈操作模块图2.23.2 功能模块的调用关系图图2.3调用关系图3.3系统子程序及功能设计本系统共设置6个函数,其中主要包括主函数。

数据结构回文判断

数据结构回文判断

数据结构回文判断在计算机科学和编程的世界里,数据结构是非常重要的一部分。

而回文判断作为一个常见的问题,在数据结构的应用中有着不少有趣的解法。

首先,咱们得搞清楚啥是回文。

简单来说,回文就是一个正着读和倒着读都一样的字符串或者序列。

比如“12321”“racecar”,不管你从前往后读,还是从后往前读,结果都是一样的。

那怎么判断一个字符串是不是回文呢?这就需要用到一些数据结构和算法的知识了。

一种常见的方法是使用数组。

我们可以把要判断的字符串的每个字符都存到一个数组里,然后从数组的两头开始比较。

一头从开头,一头从结尾,一个一个地比,如果对应的字符都一样,那就说明是回文;只要有一对不一样,那就不是回文。

举个例子,比如要判断“racecar”这个字符串是不是回文。

我们先把它的每个字符存到一个数组里:'r','a','c','e','c','a','r'。

然后从两头开始比较,先比较第一个字符'r'和最后一个字符'r',一样;再比较第二个字符'a'和倒数第二个字符'a',也一样;就这样一直比下去,发现都一样,所以“racecar”就是回文。

不过,使用数组来判断回文有一个小小的问题。

那就是如果字符串很长,需要的存储空间就会比较大。

这时候,我们可以考虑使用栈这种数据结构。

栈的特点是先进后出。

我们可以把字符串的前半部分字符依次压入栈中,然后再依次取出栈顶的字符和字符串后半部分的对应字符进行比较。

比如说对于字符串“12321”,我们先把“123”依次压入栈中,然后从字符串的第四个字符开始,和从栈中取出的字符比较。

先取出栈顶的 3 和第四个字符 2 比较,不一样,那就不是回文;如果都一样,那就是回文。

除了栈,队列也能派上用场。

我们可以把字符串的前半部分放入队列,后半部分按照相反的顺序放入另一个队列。

然后依次取出两个队列的队头元素进行比较,如果都一样,就是回文,否则就不是。

回文判断的算法实验报告

回文判断的算法实验报告

实验题目回文判断的算法一、需求分析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&序列2’模式的字符序列。

其中序列1和序列2中都不含字符‘&’,且序列2是序列1的逆序列。

例如,‘a+b&b+a’是属该模式的字符序列,而‘1+3 &3 -1’则不是。

思路:首先建立一个字符数组,长度为100,然后向数组中写入索要判断的字符串。

定义两个指针,一个指向队头,一个指向队尾,队头的指针不断递增,队尾的指针不断递减,在P1<P2的前提下,两个地址上的数据进行比较,如相等则两地址分别向中间靠拢,如对比的结果不同则跳出,但此时P1指针小于P2指针,所以判断字符串不是回文;如两者一直相等直到他们的地址P1=P2或P1>P2(字符串为奇数个)时,跳出并判断为回文;在这其中P1指针的值与P2指针的值有不等的情况就直接判定不是回文。

代码源:// huiwen.cpp : Defines the entry point for the console application. //#include <stdio.h>#include <string.h>int main( void ){char str[100];printf("请输入字符串:");gets( str ); //输入字符char *p1 = str, *p2 = str + strlen(str) - 1;//指针定义for( ; p1 < p2 && *p1 == *p2; ++p1, --p2 );//FOR循环体为空puts( p1 < p2 ? "所输字符串不是回文" : "所输字符串是回文" );return 0;}运行结果:实验结论:通过本次的课程设计,这里的回文就是把回文是指正读和反读均相同的字符序列,所以可以用程序将字符串颠倒后与原字符串相比较,所用到的数据结构有单链表和栈,单链表用于存储字符串,栈用于对单链表中字符串的判定。

单链表的基本操作及回文判断

单链表的基本操作及回文判断

实验一单链表的基本操作一.要求:(1)依次从键盘读入数据,建立带头结点的单链表;(2)输出单链表中的数据元素(3)求单链表的长度;(4)根据指定条件能够取元素和修改元素;(5)实现在指定位置插入和删除元素的功能。

二:算法设计:(1)用到的结构:逻辑结构(循环结构,条件结构,顺序结构)存储结构(线性单链表)(2)算法设计思路:首先利用尾插发创建一个单链表status createlist(LinkList &L)然后通过void print(LinkList L)方法输出,通过int ListLength(LinkList L)方法得到链表的长度,通过char GetElem(LinkList L,int i)方法,当第i 个元素存在时,其值赋给e并返回,然后通过status ListInsert(LinkList &L,int i,ElemType e) 在头结点单链线性表L中第i个位置之前插入元素e,最后通过status ListDelete(LinkList &L,int i) 删除L中第i个元素,并用e 返回其值。

三:调试和测试:(1)调试过程总结:这些是对但链表的基本操作,算是对单链表的总结。

C++不同于java,需要定义如OK,false等。

还有有的包没有正确的引入。

(2)三组测试数据及实验结果:第一组:测试ascxzbn第二组:测试dbcmgkfko第三组:测试oehfdklsdjsk实验二回文判断一实验要求:(1)数据从键盘读入;(2)输出要判断的字符串;(3)利用栈的基本操作对给定的字符串判断其是否是回文,若是则输出“Yes”,否则输出“No”。

二:算法设计:(1)用到的结构:逻辑结构(循环结构,条件结构,顺序结构)存储结构(链式栈)(2)算法设计思路:先创建一个栈的大小为100,然后用void InitStack( SeqStack *S)方法初始化一个空栈,紧接着用int EmptyStack(SeqStack *S)还有int FullStack (SeqStack *S)分别判断栈是空还是满。

数据结构C语言版判断回文数实验报告

数据结构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)了解复杂问题的递归算法设计。

本次实验中,下列实验项目选做一。

1、顺序栈的基本操作[问题描述]设计算法,实现顺序栈的各种基本操作[基本要求](1)初始化栈s。

(2)从键盘输入10个字符以$结束,建立顺序栈。

(3)从键盘输入1个元素,执行入栈操作。

(4)将栈顶元素出栈。

(5)判断栈是否为空。

(6)输出从栈顶到栈底元素。

要求程序通过一个主菜单进行控制,在主菜单界面通过选择菜单项的序号来调用各功能函数。

2、链栈的基本操作[问题描述]设计算法,实现链栈的各种基本操作[基本要求](1)初始化栈s。

(2)从键盘输入10个字符以$结束,建立带头结点的链栈。

(3)从键盘输入1个元素,执行入栈操作。

(4)完成出栈操作。

(5)判断栈是否为空。

(6)输出从栈顶到栈底元素。

(7)输出链栈的长度。

要求程序通过一个主菜单进行控制,在主菜单界面通过选择菜单项的序号来调用各功能函数。

3、循环队列的基本操作[问题描述]设计算法,实现循环顺序队列的建立、入队、出队等操作。

[基本要求](1)从键盘输入10个字符以$结束,建立循环队列,并显示结果。

(2)从键盘输入1个元素,执行入队操作,并显示结果。

(3)将队头元素出队,并显示结果。

(4)要求程序通过一个主菜单进行控制,在主菜单界面通过选择菜单项的序号来调用各功能函数。

4、只用尾指针表示的循环链表队列的综合操作[问题描述]假设以带头结点的的循环链表表示队列,并且只设一个指针指向队尾元素的结点(注意不设头指针),试编写队列初始化、入队、出队函数。

[基本要求及提示](1)首先定义链表结点类型。

(2)编写带头结点的循环链表的初始化函数,只用尾指针表示。

(3)编写入队函数、出队函数。

(4)在主函数中编写菜单(1.初始化;2.入队;3.出队;4.退出),调用上述功能函数。

数据结构回文序列判断实验报告简版

数据结构回文序列判断实验报告简版

数据结构回文序列判断实验报告数据结构回文序列判断实验报告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课设(判断回文)报告

C课设(判断回文)报告

目录一、需求分析 (2)二、概要设计 (2)三、详细设计 (4)四、调试分析 (9)五、用户手册 (9)六、测试数据 (10)七、附录 (11)一、需求分析⒈用栈及队列的基本操作完成对字符串是否为回文的判断,其中栈及队列都是作为单独的子函数存在。

⒉通过创建栈和队列来存放字符串,然后分别取出栈和队列里元素,一个个比较,如果到栈和队列到最后一个元素从两边出来的字符都相同,则能说明用户输入的字符串为回文,否则就不是。

⒊用户要从屏幕上输入一串字符,完成对栈及队列的存储。

⒋程序完成对用户输入的字符串进行存储,然后完成对字符串的输出,比较丛栈和队列中出来的字符,然后进行判断。

⒌程序执行命令:⑴接受用户输入字符串;⑵比较判断从栈和队列中出来的字符;⑶输出最后判断的结果。

二、概要设计⒈设计栈和队列的抽象数据类型定义:基本操作: 操作结果stinit(s) 构造一个空栈,完成对栈的初始化squinit(q) 构造一个空队列,完成对队列的初始化q stpush(s,c) 完成字符进栈的操作enqueue(q,c) 完成字符进队列的操作stempty(s),quempty(q) 判断栈和队列中是否还有元素stpop(s),dequeue(q) 比较出栈与出队列的字符是否匹配⒉判断字符基本操作:stpop(s)==dequeue(q);初始条件:在子函数中已经定义了栈与队列,而且已经将字符分别输入空的栈和队列中,现在的关键就在于判断从栈和队列里出来的元素是否相同。

操作结果:如果输入到栈和队列元素相同,那么代表输入的字符为回文字符。

3. 本程序模块结构⑴主函数模块void main(){初始化;为栈和队列申请空间;调用栈和队列功能子函数;判断从栈和队列出来的字符是否相同;得出最终的结果;⑵栈模块----实现栈抽象数据类型,完成对栈的初始化,进栈和出栈的操作。

⑶队列模块----实现队列抽象数据类型,完成对队列的初始化,进队列和出队列的操作。

回文判断 实验二

回文判断 实验二
(3)主函数:void main()
。。。。。。
4.详细设计
#include <stdio.h>
#define SIZE 50
int isPalindrome(char str[]);
int elementSize=0;
static int i=0;
int main()
{
int j=0,result;
{
/*把数组元素前后对应比较,即第一个元素与最后一个元素比较是否相等,依此类推*/
if(i>=elementSize-i-1)//说明是回文串
return 1;
else if(str[i]==str[elementSize-i-1])
{
i++;//i为全局静态变量
isPalindrome(str);
}
else //出现不相等的情况,说明不是回文串,返回0
return 0;
}
测试数据及结果:
实验总结:通过本次试验我从中熟悉掌握了栈和队列的特点,掌握与应用栈和队列的基本操作算法,训练和提高结构化程序设计能力及程序调试能力。
j++;
scanf("%c",&element);
}
if(isPalindrome(str))
printf("该字符串是回文字符串\n");
else
printf("该字符串不是回文字符串\n");
// system("pause");
return 0;
}
/*函数功能:判断字符串是否为回文串*/
int isPalindrome(char str[])

Java实验--关于简单字符串回文的递归判断实验

Java实验--关于简单字符串回文的递归判断实验

Java实验--关于简单字符串回⽂的递归判断实验⾸先题⽬要求写的是递归的实验,⼀开始没注意要求,写了⾮递归的⽅法。

浪费了⼀些时间,所谓吃⼀堑长⼀智。

我学习到了以后看实验的时候要认真看实验中的要求,防⽌再看错。

以下是对此次的实验进⾏的分析:1)递归是运⽤到了栈的思想2)回⽂是⼀段从中间开始倒置的⽂字,回代的过程中出现不同的符号的时候就说明这段⽂字不是回⽂了根据上⾯对回⽂判断的分析,就拿最简单的121来说,要每个字符判断直⾄2所在的位置,然后依次回代判断前⾯的1和后⾯的1的位置(上述的描述就类似于栈的思想)。

有关于栈还有递归其实我并不熟悉,所以此次的实验对我来说算是⼀次挑战吧。

接下来贴出实验的代码(利⽤递归实现回⽂的判断):package huiwen;import java.util.Scanner;public class Huiwen {public static void main(String arg[]){String sz=new String();Scanner scan=new Scanner(System.in);while(!sz.equals("-1")){System.out.println("-------------------------------------\n请输⼊⼀个字符串判断是不是回⽂(输⼊-1结束输出):");if(scan.hasNext()){sz=scan.next();if(sz.equals("-1"))break;}if(isHuiwen(sz,0)) //给递归⼀个起点直⾄字符串的中间,并判断中途有没有不等的情况,如果出现中途不等返回false,反之返回trueSystem.out.println("该字符串是回⽂\n");else System.out.println("该字符串不是回⽂\n");}scan.close();System.out.println("结束判断");}public static boolean isHuiwen(String s,int n){int num=s.length();if(num/2!=n){if(isHuiwen(s,n+1)){if(s.charAt(n)==s.charAt(num-n-1))return true;else return false;}}else if(s.charAt(n)==s.charAt(num-n-1))return true;return false;}}回⽂的实验截图,在判断的过程中没有错误。

回文

回文

实验二栈和队列的基本操作及其应用一、实验目的1、掌握栈和队列的顺序存储结构和链式存储结构,以便在实际中灵活应用。

2、掌握栈和队列的特点,即后进先出和先进先出的原则。

3、掌握栈和队列的基本运算,如:入栈与出栈,入队与出队等运算在顺序存储结构和链式存储结构上的实现。

二、实验内容本次实验提供4个题目,每个题目都标有难度系数,*越多难度越大,学生可以根据自己的情况选做,其中题目一是必做题,其它选作!题目一:回文判断(*)[问题描述]对于一个从键盘输入的字符串,判断其是否为回文。

回文即正反序相同。

如“abba”是回文,而“abab”不是回文。

[基本要求](1)数据从键盘读入;(2)输出要判断的字符串;(3)利用栈和队列对给定的字符串判断其是否是回文,若是则输出“Yes”,否则输出“No”。

[测试数据]由学生任意指定。

三、算法设计1、算法思想主要设计了两个主体。

一个栈,一个队列。

先把数据输入到栈和队列里,再分别用栈和队列把字符串输出,要是字符串一样,那么就是回文序列,反之,不是。

四、本函数包含七个模块1)主函数main()1)写了while循环2)主要代码:while(ch!='\n'){push(s,ch);EnQueue(q,ch);ch = getchar();}//当不敲回车时,往栈和队列中压入字符pop(s,cha1);DeQueue(q,cha2);while(cha1!='#'){if(cha1==cha2)//如果两个返回的地址相同(字符串相同),flag=1flag=1;else{flag=0;break;}2)栈的初始化InitStack(SqStack &s)1)先为栈分配空间,若成功,则s.top = s.base;s.stacksize = STACK_INIT_SIZE;3)入栈push(SqStack &s,char e)1)先判断是否栈满2)如果栈满S.base= = (char*)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(char));//增加分配的空间exit(OVERFLOW);s.top=s.base+s.stacksize;s.stacksize+=STACKINCREMENT;4)出栈pop(SqStack &s,char &e)1)判断是否栈空,若空,则退出,若不空继续出栈5)队列的初始化InitQueue(LinkQueue &q)1)把头指针和尾指针都指向NULL(头结点)2)主要代码:q.front = q.rear = (Que)malloc(sizeof(QNode));if(!q.front)exit(OVERFLOW);q.front->next = NULL;6)入队EnQueue(LinkQueue &q,char e)1)尾插法2)主要代码:p->data = e;p->next = NULL;q.rear->next = p;//把p插入尾部q.rear = p;//让rear一直指向最后一个结点7)出队DeQueue(LinkQueue &q,char &e)1)先把front指向的指针删除掉,然后把front移向删除掉的下一个结点,直到最后一个的时候,把尾指针和头指针指向头结点。

数据结构-回文序列判断

数据结构-回文序列判断

回文序列判断目录一、实验目的 (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. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验内容:
1.问题描述
利用栈和队列判断字符串是否为回文。称正读与反读都相同的字符序列为“回文”序列。要求利用栈和队列的基本算法实现判断一个字符串是否为回文。栈和队列的存储结构不限。
2.数据结构类型定义
typedef struct
{
char elem[MAX];
int top;
}SeqStack; 顺序栈
{
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);
printf("\n");
}
}
测试数据及结果:
实验总结:读取一个字符,同时存储在顺序栈与链队列之中,直到字符序列的最后一个字符为*停止插入。在程序中设置了一个标志位flag,将输入的序列分别做入栈、出栈、入队、出队操作,若出栈与出队的数据完全一致,则将flag标志为1,否则为零。Flag为1,则表示该序列是回文序列,否则,为非回文序列。
洛阳理工学院实验报告
系别
计算机系
班级
B130532
学号
B13053235
姓名
李登辉
课程名称
数据结构
实验日期
2014.3.28
实验名称
栈和队列的基本操作
成绩
实验目的:
熟悉掌握栈和队列的特点,掌握与应用栈和队列的基本操作算法,训练和提高结构化程序设计能力及程序调试能力。
实验条件:
计算机一台,Visual C++6.0
#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;
}
printf("正序字符串为:\n");
for(i = 0;i<cnt+1;i++)
{
DeleteQuene(&q,&b[i],cnt);
printf("%c",b[i]);
}
printf("\n");
printf("逆序字符串为:\n");
for(i = 0;i<cnt+1;i+c[i]);
3.模块划分
void InitStack(SeqStack *S):栈初始化模块,
int Push(SeqStack *S,char x,int cnt):入栈操作
int Pop(SeqStack * S,char * x):出栈操作
void InitQuene(SeqQuene *Q):队列初始化
}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 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个字符。\n",cnt);
InitStack(&s);
InitQuene(&q);
for(i = 0;i<cnt;i++)
{
EnterQuene(&q,a[i],cnt);
Push(&s,a[i],cnt);
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>
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)
printf("%c",c[i]);
}
printf("\n");
for(i = 0;i<cnt+1;i++)
{
if(b[i] == c[i])
flag = 1;
else
{
flag = 0;
break;
}
}
if(flag)
printf("此序列是回文序列!");
else
printf("此序列不是回文序列!");
相关文档
最新文档