判断回文串

设计一个顺序栈（包括栈的初始化，入栈，出栈，判栈空等操作）和一个链式队列（包括队列的初始化，进队，出队，判队空等操作），并编制主程序main{}利用这个栈队列实现判断一个字符串是否是“回文字符串”的程序，是则打印“yes”，否则打印“no”。

说明：“回文字符串”的定义：若一个字符串与其自身的逆串相等，则称该字符串为回文字符串。例如：CHINANIHC就是一个回文字符串。

#include"stdio.h"
#include"stdlib.h"
#include"stdbool.h"
#include"malloc.h"


#define MAX_SIZE 20
typedef char ElemType;


typedef struct {    //栈结构体
    ElemType *base;
    ElemType *top;
    int size;
}Stake;

void Stake_Init(Stake *s){   //初始化
    s->base = s->top = (ElemType *)malloc(MAX_SIZE*sizeof(ElemType));
    s->size = MAX_SIZE;
}

void Stake_push(Stake *s, ElemType e){  //入栈
    if(s->top - s->base > sizeof(ElemType)*s->size )
        printf("The Stake is Filled\n");
    else{
        *s->top = e;
        s->top++;
    }
}

void Stake_pop(Stake *s){  //出栈
    if(s->top == s->base)
        printf("The Stake is Empty");
    else{
        s->top--;
    }
}

char Stake_get_top(Stake *s){   //获取栈顶元素
    if(s->base == s->top)
        exit(1);
    return *(s->top-1);
}

bool Stake_empty(Stake *s){   //判别栈空
    if(s->top == s->base)
        return true;
    return false;
}


typedef struct Node{   //链式队列节点结构体
    ElemType data;
    struct Node *next;
}Node;

typedef struct{   //队列结构体
    Node *front;
    Node *rear;
    int size;
}Queue;

void Queue_init(Queue *q){  //初始化
    q->front = q->rear = (Node *)malloc(sizeof(Node));    //带头结点
    q->front->next = NULL;
    q->size = 0;
}

void Queue_push(Queue *q , ElemType e){   //入队
    Node *s = (Node *)malloc(sizeof(Node));
    s->data = e;
    s->next = NULL;
    q->rear->next = s;
    q->rear = s;
    q->size++;
}

void Queue_pop(Queue *q){   //出队
    if(q->front == q->rear)
        printf("The Queue is Filled");
    q->front = q->front->next;
    q->size--;
}

char Queue_get_front(Queue *q){   //获取队头元素
    char e = q->front->next->data;
    return e;
}

bool Queue_empty(Queue *q){   //判别队空
    if(q->front == q->rear)
        return true;
    return false;
}


void judge(Stake *s, Queue *q ){    //判断回文串
    ElemType c;
    c = getchar();
    while(c != '\n'){
        Stake_push(s,c);
        Queue_push(q,c);
        c = getchar();
    }
    while(!Stake_empty(s)){      //出栈时字符比较
        //char e1 = Stake_get_top(s);    
        //char e2 = Queue_get_front(q);
        if(Stake_get_top(s) == Queue_get_front(q)){
            Stake_pop(s);
            Queue_pop(q);
        }else{
            printf("no");
            exit(1);
        }
    }

    printf("yes");
    
}
int main(){
    Stake stake;
    Queue queue;
    Stake_Init(&stake);
    Queue_init(&queue);
    judge(&stake,&queue);
    return 0;
}