#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef int Status;
typedef char SElemType;
typedef char QElemType;
Status Palindrome(char *word);
typedef struct{
SElemType*base;
SElemType*top;
int stacksize;
}Stack;
Status InitStack(Stack&S){
S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!S.base)exit(OVERFLOW);
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return(OK);
}
Status StackEmpty(Stack S)
{
    return S.top==S.base;
}
Status GetTop(Stack S,SElemType &e)
{
    if(S.top==S.base)
    return ERROR;
    e=*(S.top-1);
    return OK;
}
Status Push(Stack &S, SElemType e){
   if(S.top-S.base==S.stacksize){//栈满则应重新分配空间
     S.base=(SElemType *)
        realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
     if(!S.base)exit(OVERFLOW);
     S.top=(S.base+S.stacksize);//使得S.top重新指向栈顶,因realloc
     S.stacksize+=STACKINCREMENT;
   }
   *S.top++=e;    //top指向待插入位置
   return(OK);
}//Push ,复杂度O(1)
Status Pop(Stack &S,SElemType e){
    //若栈不空则栈顶元素出栈并用e带回其值
    if(S.top==S.base)return ERROR;
    e=*(--S.top);     //栈顶元素为*(S.top-1)
     return OK;
} //复杂度O(1)
typedef struct QNode {
    QElemType      data;
    struct QNode  *next;
  } QNode, *QueuePtr;
typedef struct {
  QueuePtr  front;//队头指针
  QueuePtr  rear; //队尾指针
} Queue;// 链队列
 Status InitQueue (Queue &Q) {
   // 构造一个空队列Q
   Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));
   if (!Q.front) exit (OVERFLOW);
   Q.front->next = NULL;  //莫忘！！
   return OK;
   }//时间复杂度O(1)
 Status EnQueue (Queue &Q, QElemType e) {
    // 插入元素e为Q的新的队尾元素
     QueuePtr p;
     p=(QueuePtr)malloc(sizeof(QNode));
     if (!p)exit(OVERFLOW);//存储分配失败
     p->data = e;   p->next = NULL;//莫忘！！
     Q.rear->next = p;    Q.rear = p;
     return OK;
  }//复杂度O(1)
 Status DeQueue (Queue &Q, QElemType e) {
  // 若队列不空，则删除Q的队头元素，用 e 返回其“值”
   if (Q.front ==Q.rear) return ERROR;//空队列
   QueuePtr p= Q.front->next;   e = p->data;
   Q.front->next = p->next;
   if(Q.rear == p) Q.rear = Q.front;//只1个结点时改尾指针
   free (p);
   return OK;
}//复杂度O(1)
Status Palindrome()
//算法思路：利用栈后进先出和队列先进先出的特点。分别将字符序列存到栈和队列里面。
//分别从栈和队列里面输出字符序列，并经行比较若始终相同，则字符序列word是回文。
//否则不是回文。
{
  Stack S;
  Queue Q;
  InitStack(S);
  InitQueue(Q);
  SElemType c;
  printf("请输入你要检查的字符序列，并以@结束:\n");
  while ((c=getchar())!='@'){
  Push(S,c);EnQueue(Q,c);
  }
  while(!StackEmpty(S))
  {
    SElemType a;
    QElemType b;
    Pop(S,a);
    DeQueue(Q,b);
    if(b!=a)
    {
    printf("你要检查的字符序列不是回文:\n");
    return ERROR;
    }
  else
   {
printf("你要检查的字符序列是回文:\n");
return OK;
  }
}
}
int main()
{
 Palindrome();
}
无论输入的是不是回文，最终显示结果都是"不是回文"。麻烦大家给我看一下，谢谢！

程序中带回e；

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

#define OK    1
#define ERROR    0
#define INFEASIBLE    -1
#define OVERFLOW    -2
#define STACK_INIT_SIZE        100
#define STACKINCREMENT    10

typedef int Status;
typedef char SElemType;
typedef char QElemType;

Status Palindrome(char *word);

typedef struct
{
    SElemType *base;
    SElemType *top;
    int stack_size;
}Stack;

Status Init_stack( Stack &s )
{
    s.base = (SElemType*) malloc (sizeof(SElemType)*STACK_INIT_SIZE);

    if ( NULL == s.base )
    {
        exit (OVERFLOW);
    }

    s.top = s.base;
    s.stack_size = STACK_INIT_SIZE;

    return OK;
}

bool Is_empty( Stack s )
{
    if ( s.top == s.base )
    {
        return true;
    }
    else
    {
        return false;
    }
}

Status Get_top( Stack s, SElemType &e )
{
    if ( !Is_empty(s) )
    {
        return ERROR;
    }

    e = *(s.top - 1);

    return OK;
}

Status Push( Stack &s, SElemType e )
{
    if ( s.top-s.base >= s.stack_size )
    {
        s.base = (SElemType*) realloc (s.base, sizeof(SElemType)*(s.stack_size+STACKINCREMENT));
       
        if ( NULL == s.base )
        {
            exit (OVERFLOW);
        }
        s.top = s.base + s.stack_size;
        s.stack_size += STACKINCREMENT;
    }

    *s.top++ = e; //top 

    return OK;
}

Status Pop( Stack &s, SElemType &e )
{
    if ( Is_empty(s) )
    {
        return ERROR;
    }

    e = *(--s.top);

    return OK;
}

typedef struct node
{
    QElemType data;
    struct node *next;
}QNode, *QueuePtr;

typedef struct
{
    QueuePtr front;
    QueuePtr rear;
}Queue;

Status Init_queue( Queue &q )
{
    q.front = q.rear = (QueuePtr) malloc (sizeof(QNode));

    if ( NULL == q.front )
    {
        exit (OVERFLOW);
    }

    q.front->next = NULL;

    return OK;
}

Status Enter_queue( Queue &q, QElemType e )
{
    QueuePtr p;
    p = (QueuePtr) malloc (sizeof(QNode));
    if ( NULL == p )
    {
        exit (OVERFLOW);
    }

    p->data = e;
    p->next = NULL;
    q.rear->next = p;
    q.rear = p;

    return OK;
}

Status Delete_queue( Queue &q, QElemType &e )
{
    if ( q.front == q.rear )
    {
        return ERROR;
    }

    QueuePtr p = q.front->next;
    e = p->data;
    q.front->next = p->next;

    if ( q.rear == p )
    {
        q.rear = q.front;
    }

    free( p );

    return OK;
}

Status Palindrome()
{
    Stack s;
    Queue q;

    Init_stack( s );
    Init_queue( q );

    SElemType c;

    printf("\t请输入你要检查的字符序列，并以@结束\n");

    while ( (c=getchar()) != '@' )
    {
        Push ( s, c );
        Enter_queue( q, c );
    }

    SElemType a;
    QElemType b;

    while ( !Is_empty(s) )
    {
        Pop( s, a );
        Delete_queue( q, b );

        if ( a != b )
        {
            printf("\t你要检查的字符序列不是回文\n");

            return ERROR;
        }
    }

    if ( Is_empty(s) )
    {
        printf("你要检查的字符序列是回文:\n");
        return OK;
    }

    return OK;
}

int  main()
{
    Palindrome();

    return 0;
}