回文判断（python）（c）

要求：输入一个以”@“结尾的字符串，判断其是否回文。

一、python（两种）：

        1.

s = input('请输入一个字符串：')
if not s:
    print('请不要输入空字符串！')
    s = input('请重新输入一个字符串：')

a = len(s)
i = 0
count = 1
if s[-1] == '@':
    s = s.strip("@")    
    while i <= (a/2):
        if s[i] == s[a-i-2]:
            count = 1
            i += 1
        else:
            count = 0
            break

    if count == 1:
        print('您所输入的字符串是回文')
    else:
        print('您所输入的字符串不是回文')
else :
    print('请输入“@”结尾的字符串')

        2.

S = input('请输入字符串:')
if S[-1] == '@':
    s = S.strip("@")
    if hash(s[::-1]) == hash(s):
        print("是")
    else:
        print("否")
else :
    print("重新输入")

        字符串操作

c：

#include <stdio.h> 
#include<stdlib.h> 
#define m 100 
 
typedef struct          //定义栈,顺序栈
 {  
  char data[m]; 
  int  top; 
}zhan;    

void cshz(zhan *s)      //初始化栈
{ 
  s->top=0; 
}                         

int pdzk(zhan *s)        //判断栈是否为空
{ 
  if(s->top==0)                         
  { 
    return 0; 
  } 
  else 
  { 
    return 1; 
  }              
}                        

void ruzhan(zhan *s,char x)  //入栈
{ 
  if(s->top==m)                       
   { 
     printf("栈空\n"); 
  }                         
  else                                   
   {               
     s->data[++s->top]=x;                
   } 
}                       

char chuzhan(zhan *s)        //出栈
{ 
  char y; 
  if(s->top==0)                         
  
  { 
    printf("栈空\n");    
    return '0';   
  }
  else                                 
  {     
    y=s->data[s->top];                   
    s->top=s->top-1;                       
    return y; 
  } 
}                   

typedef struct {          //定义队列，顺序队
 char data[m]; 
 int  front; 
 int  rear; 
}dui;  

 void cshdl(dui *q)      //初始化队列
{ 
  q->front=q->rear=0;                            
}                          
 
void rudui(dui *q,char e)            //入队
{
  if((q->rear+1)%m==q->front)           
   { 
    printf("队列为空\n"); 
   } 
   else 
   { 
    q->data[q->rear]=e;                
    q->rear=(q->rear+1);             
   } 
}                     
 
char chudui(dui *q)         //出队
{ 
  char f; 
  if(q->front==q->rear)                 
   { 
     printf("队列为空\n");    
     return 0; 
   } 
   else 
   { 
     f=q->data[q->front];   
	 q->front=(q->front+1);            
     return f; 
   } 
}                  
  
int  main()             
{                                 
  char c; 
  int y=0; 
  zhan *s=(zhan *)malloc(sizeof(zhan)); //sizeof判断字符数据类型或者表达式长度的运算符
  dui *q=(dui *)malloc(sizeof(dui)); //malloc分配所需的内存空间，并返回一个指向它的指针
  cshz(s);   
  cshdl(q); 
  printf("输入一个字符串:\n");
  while((c=getchar())!='@') 
  {
    ruzhan(s,c);            
    rudui(q,c); 
  } 
  while(pdzk(s))          
   { 
     if(chuzhan(s)==chudui(q)) 
     { 
      y=1;                 
      continue;            
     } 
     else                   
     { 
      y=0; 
      break;                 
     } 
   } 
   if(y==1) 
    printf("此字符串为回文\n"); 
  else 
    printf("此字符串不是回文\n");
  return 0;
}

        顺序栈、队的比对