1.使用顺序栈来判断一个单词是否为回文词
代码如下

sqstack.h //头文件
#ifndef SQSTACK_H_INCLUDED
#define SQSTACK_H_INCLUDED

#define STACK_INIT_SIZE 100
#define STACK_INCREMENT 50

typedef int SElemType;

typedef struct
{
    SElemType *base; //栈底指针
    SElemType *top; //栈顶指针
    int stacksize;
}SqStack;

void InitStack(SqStack &S); //初始化栈
void DestroyStak(SqStack &S); //销毁栈
void ClearStack(SqStack &S); //清空栈
bool StackEmpty(SqStack S); //判断栈是否为空
int StackLength(SqStack S); //返回栈的长度
bool GetTop(SqStack S,SElemType &e);  //用e返回S的栈顶指针
void Push(SqStack &S,SElemType e); //插入元素e为新的栈顶元素
bool Pop(SqStack &S,SElemType &e); //若栈不为空，则删除S的栈顶元素，用e返回其值
void StackTraverse(SqStack S,void(*visit)(SElemType)); //栈的遍历


#endif // SQSTACK_H_INCLUDED

sqstack.cpp 

#include <stdlib.h>
#include "sqstack.h"

//初始化栈
void InitStack(SqStack &S)
{
    S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
    if(!S.base)
        exit(-1);
    S.top=S.base;
    S.stacksize=STACK_INIT_SIZE;
}
//销毁栈
void DestroyStak(SqStack &S)
{
    free(S.base);
    S.base=S.top=NULL;
    S.stacksize=0;
}
//清空栈
void ClearStack(SqStack &S)
{
    S.top=S.base;
}
//判断栈是否为空，若为空，返回true，否则返回false
bool StackEmpty(SqStack S)
{
    return S.base==S.top;
}
//返回栈的长度
int StackLength(SqStack S)
{
    return S.top-S.base;
}
//得到栈S的栈顶元素
bool GetTop(SqStack S,SElemType &e)
{
    if(S.top==S.base)
        return false;
    e=*(S.top-1);
    return true;
}
//将元素e插入到栈S的栈顶
void Push(SqStack &S,SElemType e)
{
    if(S.top-S.base>=S.stacksize)
    {
        SElemType *p=(SElemType*)realloc(S.base,(S.stacksize+STACK_INCREMENT)*sizeof(SElemType));
        if(!p)
            exit(-1);
        S.top=S.base+S.stacksize;
        S.stacksize+=STACK_INCREMENT;
    }
    *S.top++=e;
}
//栈的删除
bool Pop(SqStack &S,SElemType &e)
{
    if(S.top==S.base)
        return false;
    e=*--S.top;
    return true;
}
//栈的遍历
void StackTraverse(SqStack S,void (*visit)(SElemType))
{
    for(SElemType *p=S.base;p<S.top;p++)
        visit(*p);
}

main.cpp //(主文件)

#include <stdio.h>
#include "sqstack.h"


void PrintStack(SElemType e)
{
    printf("%c\t",e);
}

bool Huiwen(char *chars)
{
    SqStack S;
    InitStack(S);
    int i;
    for(i=0;chars[i]!='\0';i++)
        Push(S,chars[i]);
    for(i=0;chars[i]!='\0';i++)
    {
        SElemType e;
        Pop(S,e);
        if(e!=chars[i])
            return false;
    }
    return true;
}

int main()
{
    char str[15];
    printf("请输入一个单词:");
    scanf("%s",str);
    if(Huiwen(str))
        printf("%s是回文词\n",str);
    else
        printf("%s不是回文词\n",str);
    return 0;
}

运行结果如下：

2.使用链栈来判断一个单词是否为回文词

LStack.h //（头文件）

#ifndef SQSTACK_H_INCLUDED
#define SQSTACK_H_INCLUDED

typedef char LElemType;

typedef struct LNode
{
    LElemType data;
    LNode *next;
}LNode,*LStack;


void Init_LStack(LStack &L); //初始化链栈
void Clear_LStack(LStack &L); //清空链栈
bool LStackEmpty(LStack L); //判断链栈是否为空
int LStackLength(LStack L);  //返回链栈的长度
bool GetTop(LStack L,LElemType &e); //得到链栈的栈顶元素
void PushLStack(LStack &L,LElemType e); //将元素e插入到链栈的栈顶
bool PopLStack(LStack &L,LElemType &e); //删除链栈的栈顶元素，并且用e返回删除的元素
void LStackTraverse(LStack L,void(*visit)(LElemType)); //遍历链栈

#endif // SQSTACK_H_INCLUDED

LStack.cpp

#include <stdlib.h>
#include "LStack.h"

//初始化链栈
void Init_LStack(LStack &L)
{
    L=(LNode *)malloc(sizeof(LNode));
    if(!L)
        exit(-1);
    L->next=NULL;
}
//清空链栈
void Clear_LStack(LStack &L)
{
    LNode *p=L->next,*r;
    L->next=NULL;
    while(p!=NULL)
    {
        r=p;
        p=p->next;
        free(r);
    }
}
//判断链栈是否为空
bool LStackEmpty(LStack L)
{
    return L->next==NULL;
}
//返回链栈的长度
int LStackLength(LStack L)
{
    int i=0;
    LNode *p=L->next;
    while(p!=NULL)
    {
        ++i;
        p=p->next;
    }
    return i;
}
//得到链栈S的栈顶指针
bool GetTop(LStack L,LElemType &e)
{
    LNode *p=L;
    if(p->next==NULL)
        return false;
    e=p->next->data;
    return true;
}
//往链栈L的栈顶插入元素e
void PushLStack(LStack &L,LElemType e)
{
    LNode *p=(LNode*)malloc(sizeof(LNode));
    p->data=e;
    p->next=L->next;
    L->next=p;
}
//删除链栈L的栈顶元素，并用e返回其值
bool PopLStack(LStack &L,LElemType &e)
{
    if(L->next==NULL)
        return false;
    e=L->next->data;
    LNode *p=L->next;
    L->next=p->next;
    free(p);
    return true;
}
//遍历链栈
void LStackTraverse(LStack L,void(*visit)(LElemType))
{
    LNode *p=L->next;
    while(p!=NULL)
    {
        visit(p->data);
        p=p->next;
    }
}

main.cpp  //(主文件)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>  //字符串头文件，调用其strlen()函数得到输入字符串的长度
#include "LStack.h"

void PrintLStack(LElemType L)
{
    printf("%c",L);
}

bool HuiWen(char *s);

int main()
{
    char chars[15];
    printf("请输入一个单词:");
    scanf("%s",chars);
    if(HuiWen(chars))
        printf("%s是回文词\n",chars);
    else
        printf("%s不是回文词\n",chars);
    return 0;
}

bool StrLen(char *str,int &j) /*定义函数，用来判断字符串长度是否为奇数或偶数
如果是偶数,则返回真,并通过引用返回(字符串的长度/2);
如果是奇数,则返回假,并通过引用返回((字符串的长度-1)/2)*/
{
    j=strlen(str);
    bool un=false;
    if(j%2==1)
        j=(j-1)/2;
    else
    {
        j=j/2;
        un=true;
    }
    return un;
}

bool HuiWen(char *s)
{
    LStack L;
    Init_LStack(L);
    int i,j;
    LElemType e;
    bool O_J=StrLen(s,j);
    for(i=0;i<j;i++)
        PushLStack(L,s[i]);
    for(i=0;i<j;i++)
    {
        PopLStack(L,e);
        if(O_J&&e!=s[i+j])
            return false;
        else if(!O_J&&e!=s[i+j+1])
            return false;
    }
    return true;
}

运行结果如下：