c语言如何判断字母回文,利用栈和队列判断字符是否是回文（C语言）

// File Name: palindrome.h

//

// Destination:利用栈和队列判断字符串是否是回文

//

#ifndef PALINDROME

#define PALINDROME

#include

// 链式队列结构的定义

typedef char ElemType;

typedef struct Node

{

char data; //

元素数据

struct Node *next;// 链式队列中结点元素的指针

}QNode,*QueuePtr;

typedef struct {

QueuePtr front;// 队列头指针

QueuePtr rear;// 队列尾指针

}LinkQueue;

// 栈结构的定义

typedef struct Stack

{

ElemType *base;

ElemType *top;

int stacksize;

}SqStack;

// 链式队列的基本操作

bool InitQueue(LinkQueue *Q);

bool EnQueue(LinkQueue *Q, ElemType e);

bool DeQueue(LinkQueue *Q, ElemType *e);

// 栈的基本操作

bool InitStack(SqStack *S);

bool Push(SqStack *S, ElemType e);

bool Pop(SqStack *S, ElemType *e);

#endif

// File Name: palindrome.cpp

//

// Destination:利用栈和队列判断字符串是否是回文

#include

#include

#include "palindrome.h"

const int STACK_INIT_SIZE = 100; //

初始分配的长度

const int STACKINCREMENT =

10; // 分配内存的增量

//操作目的： 初始化队列

//初始条件： 无

//操作结果： 构造一个空的队列

//函数参数：

//LinkQueue

*Q 待初始化的队列

//返回值：

// bool 操作是否成功

------------------------------------------------------------*/

bool InitQueue(LinkQueue *Q)

{

Q->front = Q->rear

= (QueuePtr)malloc(sizeof (QNode));

if (!Q->front)

{

exit(0);

}

Q->front->next =

NULL;

return true;

}

//操作目的： 在队列末尾插入元素e

//初始条件： 队列Q已存在

//操作结果： 插入元素e作为队列新的尾结点

//函数参数：

//LinkQueue

*Q 队列Q

//ElemType

e 待插入的数据元素

//返回值：

//bool 操作是否成功

bool EnQueue(LinkQueue *Q, ElemType e)

{

QueuePtr p =

(QueuePtr)malloc(sizeof(QNode));

if (!p)

{

exit(0);

}

p->data = e;

p->next = NULL;

Q->rear->next =

p;

Q->rear = p;

return true;

}

//操作目的： 删除链式队列的头结点

//初始条件： 队列Q已存在

//操作结果： 删除链式队列的头结点

//函数参数：

//LinkQueue

*Q 队列Q

//ElemType

*e 待插入的数据元素

//返回值：

//bool 操作是否成功

bool DeQueue(LinkQueue *Q, ElemType *e)

{

if (Q->front ==

Q->rear) //空队列

{

return false;

}

QueuePtr p =

Q->front->next;//p指向头结点的下个位置

*e = p->data;

Q->front->next =

p->next;

if (Q->rear == p)

{

Q->rear =

Q->front;

}

free(p);

return true;

}

//操作目的： 初始化栈

//初始条件： 无

//操作结果： 构造一个空的栈

//函数参数：

// SqStack

*S 待初始化的栈

//返回值：

// bool 操作是否成功

bool InitStack(SqStack *S)

{

S->base =

(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType));

if (S->base == NULL)

{

return false;

}

S->top =

S->base;

S->stacksize =

STACK_INIT_SIZE;

return true;

}

//操作目的： 压栈——插入元素e为新的栈顶元素

//初始条件： 栈S已存在

//操作结果： 插入数据元素e作为新的栈顶

//函数参数：

//SqStack

*S 栈S

//ElemType

e 待插入的数据元素

//返回值：

// bool 操作是否成功

bool Push(SqStack *S, ElemType e)

{

if (S->top -

S->base >=

S->stacksize)

{

S->base =

(ElemType

*)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(ElemType));

if

(!S->base)

{

return

false;

}

S->top =

S->base + S->stacksize;

S->stacksize +=

STACKINCREMENT;

}

*(S->top++) = e;

return true;

}

//操作目的： 弹栈——删除栈顶元素

//初始条件： 栈S已存在且非空

//操作结果： 删除S的栈顶元素，并用e返回其值

//函数参数：

//SqStack

*S 栈S

//ElemType

*e 被删除的数据元素值

//返回值：

//bool 操作是否成功

bool Pop(SqStack *S, ElemType *e)

{

if (S->top ==

S->base)

return false;

*e = (*--S->top);

return true;

}

// File Name: main.cpp

//

// Destination:利用栈和队列判断字符串是否是回文

//------------------------------------------------------

#include

#include

#include "palindrome.h"

int main ()

{

//声明一个栈一个队列

SqStack S;

LinkQueue L;

//初始化一个栈一个队列

InitStack (&S);

InitQueue (&L);

char c[30];

ElemType a,b;

printf("请输入要判断的字符，以@结束(最多30个字符)：");

scanf("%s",c);

int i = 0;

int flag1 = 0;

int flag2 = 0;

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

{

Push(&S,c[i]); //入栈

EnQueue(&L,c[i]);//入队列

flag1++;

i++;

}

while (!(S.top == S.base))

{

Pop(&S,&b);//出栈

DeQueue(&L,&a);//出队列

if (a==b)

{

flag2++;

}

else

{

break;

}

}

if (flag1 == flag2)

{

printf("\n是回文！\n\n");

}

else

{

printf("\n不是回文！\n\n");

}

system("pause");

return 0;

}