c语言利用队列判断回文_C语言怎么判断一个数是否是回文数

Ⅰ 用c语言判断一个数是否是回文数(不用循环语句)

#include<stdio.h>
#include<string.h>
intfun(char*s,inti,intlen)
{
if(len/2==i)return1;
if(*(s+i)==*(s+len-i-1)){
returnfun(s,i+1,len);
}
return0;
}

intmain(){

chars[255];
scanf("%s",s);
intlen=strlen(s);
if(len<=1){
printf("输入字符串过短！");
}
elseif(fun(s,0,len))
{
printf("是回文");
}
else
{
printf("不是回文");
}

scanf("%s",s);
return0;
}

我用递归实现了

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

用栈实现了判断回文数的操作，即把字符串依次入栈，然后出栈并依次和字符数组比较是否相等，从而判断字符序列是否回文数，代码如下：

#include"stdio.h"

#include"stdlib.h"

#include"string.h"

#defineEMPTY0

#defineFULL10000

#defineMAX10000

typedefchardata;

typedefstructelem{

datad;

structelem*next;

}elem;

typedefstructstack{

intcnt;

elem*top;

}stack;

voidinitialize(stack*stk);

voidpush(datad,stack*stk);

datapop(stack*stk);

boolempty(conststack*stk);

boolfull(conststack*stk);//栈操作函数

voidinitialize(stack*stk)

{

stk->cnt=0;

stk->top=NULL;

}

boolempty(conststack*stk)

{

returnstk->cnt==EMPTY;

}

boolfull(conststack*stk)

{

returnstk->cnt==FULL;

}

voidpush(datad,stack*stk)

{

elem*p;

if(!full(stk))

{

p=(elem*)malloc(sizeof(elem));

p->d=d;

p->next=stk->top;

stk->top=p;

stk->cnt++;

}

datapop(stack*stk)

{

datad;

elem*p;

if(!empty(stk))

{

d=stk->top->d;

p=stk->top;

stk->top=stk->top->next;

stk->cnt--;

free(p);

}

returnd;

}

intmain(void)

{

datainput[MAX];

stacktemp;

inti=0;

intflag=0;

initialize(&temp);//初始化临时栈

scanf("%s",&input);//输入字符串

while(input[i]!='@')

{//字符串入栈

push(input[i],&temp);

i++;

}

while(!empty(&temp))

{//字符依次出栈和字符数组比较，判断是否回文数

if(temp.top->d==input[flag])

{

pop(&temp);

flag++;

}

else

{

printf("此字符序列不是回文数! ");

break;

}

if(empty(&temp))

printf("此字符序列是回文数! ");

return1;

}

运行结果：

Ⅲ C语言怎么判断一个数是否是回文数

所谓回文数，就是说一个数字从左边读和从右边读的结果是一模一样的，比如12321。

以下是判断一个数是否为回文数的代码：

Ⅳ c语言判断是否为回文

首先清楚什么是回文。。。我们称正读和反读都相同的字符序列为“回文”，如“abba”、“abccba”、12321、123321是“回文”。
然后再看程序，把长度为n的字符串的每一个字符排下标，即从0到n-1，要判断是否回文，就是把一串字母进行前后比对，即下标0的字符和下标为n-1的字符，1与n-2，2与n-3。。。
for
(i
=
0;
i
<
len
/
2;
i++)
{
if
(str[i]
!=
str[len-1-i])
{
break;
{{{{这里是什么意思啊}}}}}}
//
这里是判断不符号回文的情况，只要两个字符不符合，那这整个字符串就不是，所以break跳出循环判断
}
}
if
(i
==
len
/
2)
{{{{我不懂这里是什么意思}}}}}}
//
长度为n的字符串最多只能比对len
/
2次，那么如果每对都符合，那就是回文啦
{
printf(“%s
shi
hui
wen.\n“,
str);
}

Ⅳ 如何用C语言中的队列（链表实现）设计一个算法来判断一个字符串是否为回文

#include "stdio.h"
#include "stdlib.h"
typedef struct DNode
{
struct DNode *piror,*next;
char data;
}DNode,*Doublelist;
main()
{
Doublelist l,p,q,s;
char elem;
l=(Doublelist)malloc(sizeof(DNode));
l->piror=l->next=NULL; q=l;p=l;
printf("Input the element: "); /*一个一个录入*/
scanf("%c",&elem);
getchar();
while(elem!='@') /*元素录入，中间以&分开，以@结束*/
{
s=(Doublelist)malloc(sizeof(DNode));
s->data=elem;
q->next=s;
s->piror=q;
q=s;
s->next=NULL;
printf("Input the element: ");
scanf("%c",&elem);
getchar(); if(q->data=='&')p=q;

}
l->next->piror=NULL;
free(l);
q=p;
while(p->piror->data==q->next->data&&p->piror!=NULL&&q->next!=NULL)
{
p=p->piror; q=q->next;
}
if(p->piror==NULL&&q->next==NULL)
printf("Is palindrome!");
else
printf("Not palindrome!");
getch();
}

元素录入，以“&”为中间符号，以“@“为结束判断。

Ⅵ C语言编写程序判断回文数

要判断一个数n是否回文数，可以利用一个简单的循环就可以解决问题的。先保存好n的一个副本n1,初始化一个变量n2=0，然后每次取n1的末位数后添加到n2的末位，并把原n1的末位去掉。如此循环，当n1为0时循环结束，此时再判断，若n2==n，则n就是一个“回文数”了。
#include<stdio.h>
int main()
{ int n,n1,n2;
scanf("%d",&n);
n1=n;
for(n2=0;n1;n1/=10)
n2=n2*10+n1%10;
printf("%s\n",n2==n?"Yes":"No");
return 0;
}

Ⅶ 回文判断，写一个C++程序同时用栈和队列判断回文（急！！）

#include <iostream>
using namespace std;

//定义栈
typedef struct stack {
char bata;
struct stack *next;
}Stack;
//定义队列
typedef struct QNode {
char data;
struct QNode *next;
}QNode, *QueuePtr;
typedef struct {
QueuePtr front;
QueuePtr rear;
}LinkQueue;

int main()
{
Stack *top = new Stack;
if(!top) exit(1);
top = NULL;//初始化栈

LinkQueue *x = new LinkQueue;
if(!x) exit(1);
x->front = x->rear=NULL;//初始化队列

cout<<"请输入要检测的字符串，可以包含空格，以@结束"<<endl;
char sr[100];
sr[0] = ' ';
int i=-1;
do{
i++;
cin>>sr[i];
stack *s1 = new stack;
if(!s1) exit(1);
if(i==0)
{
s1->next = NULL; //输入栈第一个数据
s1->bata=sr[i];
top = s1;
}
s1->bata = sr[i];
s1->next = top;
top = s1;

QNode *x1 = new QNode;
if(!x1) exit(1);
if(i==0) //输入队列第一个数据
{
x1->data = sr[i];
x->front = x1;
x->rear = x1;
x->front->next = NULL;
}
x1->data = sr[i];
x->rear->next = x1;
x->rear = x1;

} while(sr[i]!='@');
cout<<"检测结果"<<endl;
if(top==NULL&&x->front==NULL)
cout<<"未输入！！！"<<endl;
top = top->next; //将'@'字符删除
while(top!=NULL&&x->front!=NULL)
{
if(top->bata!=x->front->data)
{
cout<<"此字符串不是回文！"<<endl;
return 0;
}
else
{
cout<<"此字符串是回文。"<<endl;
return 0;
}

}
}里面有具体操作没有用函数分开写，但都是按栈和队列写的

Ⅷ 用c语言如何实现判断回文

下面介绍了几种判断回文的方法：

你提问的第一个地方，比如你输入了个5个字符的字符串，abcba 先判断第一个和最后一个是否相同，再判断第二个和倒数第二个。
如果相等程序正常执行，如果不相等，break就跳出循环，你提问的第二个地方就是i 如果等于 len/2说明上边循环式正常退出。
那就是说前后一一对比都相同，是回文数，不等于len/2说明是由break退出导致，既前边和后边某一位不相同
若输入 abbci=0str[0]='a' str[4-1-0]='c' 执行break;跳出for循环循环结束 i=0 所以判断不是回文若输入ab=0str[0]='a' str[4-1-0]='a' i=1str[1]='b' str[4-1-1]='b'i=2for循环条件不满足i

Ⅸ 用C#描述数据结构的栈和队列的方法判断是否为回文。

//-----------以下是判断方法，堆栈和队列的创建方法很普通，如果你还要的话再补充------------
//采用堆栈判断回文
//思路就是：利用栈的后进先出的方法，将目标字符串先压入一个栈
//如果该字符串是回文，则他的出栈序列就与原序列相同
//采用队列判断回文
//与堆栈正好相反，利用先进先出
bool Check(char[] target)
{
//创建一个栈或队列的实例
StackOrQueue temp = new StackOrQueue();

//将目标字符串压入栈或队列
for(int i = 0; i < target.Length; i++)
temp.push(target[i]);

//利用栈或队列的性质，判断是否为回文
for(int i = 0; i < target.Length; i++)
//for(int i = target.Length - 1; i > 0; i--) 如果是队列法只需要将上句改为这句
if(temp.pop() != target[i])
return false;

return true
}

Ⅹ C语言数据结构，用链式队列和链式栈判断一个字符串是否为回文

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

constMaxStackSize=50;

typedefcharElemType;

typedefstructsnode{
	ElemTypedata;
	structsnode*next;
}*LinkStack,*psNode;

LinkStackGetEmptyStack(){//初始化
	LinkStackhead=(psNode)malloc(sizeof(structsnode));
	if((head)==NULL){
		printf("内存空间不足无法插入！
");
		returnNULL;
	}
	head->data='0';
	head->next=NULL;
	returnhead;
}

intStackNotEmpty(LinkStackhead){//是否为空
	return(head->next!=NULL);
}

intStackPush(LinkStackhead,ElemTypex){//入栈
	psNodep=(psNode)malloc(sizeof(structsnode));
	if(p==NULL){
		printf("内存空间不足无法插入！
");
		return0;
	}
	p->data=x;
	p->next=head->next;
	head->next=p;
	return1;
}

intStackPop(LinkStackhead,ElemType*x){//删除元素（弹出）
	psNodep=head->next;
	if(StackNotEmpty(head)){
		*x=p->data;
		head->next=p->next;
		free(p);
		return1;
	}
	return0;
}

typedefstructqnode{//队列
	ElemTypedata;
	structqnode*next;
}*pqNode;

typedefstructqueue{
	pqNodefront;
pqNoderear;
}*LinkQueue;

LinkQueueGetEmptyQueue(){//初始化
	LinkQueueQ=(structqueue*)malloc(sizeof(structqueue));
	if(Q==NULL){
		printf("内存空间不足无法插入！
");
		returnNULL;
	}
	Q->rear=NULL;
Q->front=NULL;
	returnQ;
}

intQueueNotEmpty(LinkQueueQ){//是否为空
	return(Q->front!=NULL);
}

intQueueAppend(LinkQueueQ,ElemTypex){//入队列
	structqnode*p=(structqnode*)malloc(sizeof(structqnode));
	if(p==NULL){
		printf("内存空间不足!
");
		return0;
	}
	p->data=x;
	p->next=NULL;
	if(Q->front==NULL)//队列为空
		Q->front=Q->rear=p;
	else{
		Q->rear->next=p;
		Q->rear=p;
	}
	return1;
}

intQueueDelete(LinkQueueQ,ElemType*d){//出队列（删除）
	pqNodep;
	if(QueueNotEmpty(Q)){
		*d=Q->front->data;
		p=Q->front;
		Q->front=p->next;
		if(p->next==NULL)Q->rear=NULL;
		free(p);
		return1;
	}
	printf("队列已空无数据出队列！
");
	return0;
}
		
typedefstructsqstack{//顺序栈（进制）
	ElemTypestack[MaxStackSize];
	intsize;
}SequenceStack;

voidStackInitiate(SequenceStack*S){
	S->size=0;
}

intStackNotEmpty(SequenceStack*S){
	return(S->size>0);
}

intStackPush(SequenceStack*S,ElemTypex){
	if(S->size>=MaxStackSize){
		printf("堆栈已满无法插入!
");
		return0;
	}
	S->stack[S->size]=x;
	++S->size;
	return1;
}

intStackPop(SequenceStack*S,ElemType*d){
	if(S->size==0){
		printf("堆栈已空!
");
		return0;
	}
	--S->size;
	*d=S->stack[S->size];
	return1;
}

intmain(){//主函数在这里
	LinkStackhead=GetEmptyStack();
	LinkQueueQ=GetEmptyQueue();
//	SequenceStackmyStack;
	charx,d;
	inti=0,flag;
	charstr[MaxStackSize];

printf("输入字符串：");
	scanf("%s",str);
	while(str[i]){
		StackPush(head,str[i]);
		QueueAppend(Q,str[i]);
		++i;
	}
	while(StackPop(head,&x)&&QueueDelete(Q,&d)&&flag)
		flag=(x==d);
	if(flag)printf("是回文!
");
	elseprintf("不是回文!
");
	return0;
}

c语言利用队列判断回文

与c语言利用队列判断回文相关的内容