DS之顺序栈和链队实现回文判断

        顺序栈和链队的基本操作就不再一一列举了，要想实现回文判断，先来了解什么是回文？“回文”一字符串正着读和反着读是相同的字符序列，如“abcba”,"abba"为"回文"，“abab”则不是“回文”。

        其次就是顺序栈和链队如何实现回文的判断？将输入的字符串依次入栈和入队，然后再依次出栈和出队，由于入栈和入队是相同的序列，然而出栈和出队是相反的序列，这就实现了回文的判断。

        最后考虑要用到顺序栈和链队的什么基本操作？需要用到栈的基本操作为;1构造一个空栈，2判断栈是否为空，7出栈，8进栈。需要用到链队的基本操作为：1初始化链队，7出队，8入队。

        实现判断回文的函数代码为：

<span style="font-size:18px;">Status huiwen(SqStack &S,LinkQueue &Q)//判断回文的函数
{
	char a,b,c;
	c=getchar();//接受输入的字符串
     while(c!='@')
     { 
		Push(S,c);     
		EnQueue(Q,c);
		c=getchar();
	}
     while(!StackEmpty(S))
    { 
	   Pop(S,a);     
	   DeQueue(Q,b);
    }
    if(a!=b) 
    {
	   return ERROW;
    }
    else
    {
       return OK;
    }
} </span>

       在主函数中只需构建一个顺序栈和链队，再定义一个接受输入的字符串，基本上就实现了回文的判断，输入一个以“@”结束的字符串，回文判断的代码为：

<span style="font-size:18px;">#include <iostream>
using namespace std;
//两个C语言的头文件库
#include <malloc.h>
#include <stdlib.h>
//以下是宏定义
#define OK 1
#define ERROW 0
#define OVERFLOW -2
#define TRUE 1
#define FALSE 0
#define INFEASIBLE -1
#define STACK_INIT_SIZE 100//存储空间初始分配量
#define STACKINCREMENT 10//存储空间分配增量
//以下是类型重新定义
typedef char SElemType;//重新定义SElemType为int型
typedef int Status;//重新定义Status为int型
typedef char QElemType;//重新定义QElemType为int型
//下面的是栈的定义和基本操作
typedef struct{//重新定义SqStck为结构类型
	SElemType *base;//栈底指针
	SElemType *top;//栈顶指针
	int stacksize;//栈的当前可使用的最大容量
}SqStack;
typedef struct QNode{//重新定义一个结点结构
    QElemType   data;
    struct QNode  *next;
}QNode, *QueuePtr;

typedef struct {//定义的一个链队
    QueuePtr  front;//队头指针   
    QueuePtr  rear;//队尾指针
}LinkQueue;//定义的一个结构变量 
//1初始化队列
Status InitQueue(LinkQueue &Q)
{
    Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode)); 
    if(!Q.front)
	{
		exit(OVERFLOW);
	}
    Q.front->next=NULL;
    return OK;
}
//入队列
Status EnQueue(LinkQueue &Q,QElemType e)
{
    QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
    if(!p) 
	{
		exit(OVERFLOW);
	}
    p->data=e; 
	p->next=NULL;
    Q.rear->next=p;
    Q.rear=p;
    return OK; 
}
//出队列
Status DeQueue(LinkQueue &Q,QElemType &e)
{
   if(Q.front==Q.rear) 
   {
	   return ERROW;
   }
   QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
   p=Q.front->next;
   e=p->data;
   Q.front->next=p->next;
   if(Q.rear==p) 
   {
	   Q.rear=Q.front;
   }
   free(p);
   return OK;
}
//1构造一个空栈
Status InitStack(SqStack &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;
}
//2判断栈是否为空
Status StackEmpty(SqStack S)
{
	if(S.base==S.top)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}
//7出栈
Status Pop(SqStack &S,SElemType &e)
{
	if(S.top==S.base)
	{
		return ERROW;
	}
	e=*--S.top;
	return OK;
}
//8进栈
Status Push(SqStack &S,SElemType e)
{
	if(S.top-S.base>=S.stacksize)
	{
		//栈满追加存储空间
		SElemType *newbase=(SElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
     if(!newbase)
	{
		exit(OVERFLOW);
	}
		S.base=newbase;
		S.top=S.base+S.stacksize;
		S.stacksize+=STACKINCREMENT;
	}
	*S.top++=e;
	return OK;
}
Status huiwen(SqStack &S,LinkQueue &Q) 
{
	char a,b,c;
	c=getchar();//接受输入的字符串
    while(c!='@')
    { 
		Push(S,c);     
		EnQueue(Q,c);
		c=getchar();
	}
   while(!StackEmpty(S))
   { 
	   Pop(S,a);     
	   DeQueue(Q,b);
   }
   if(a!=b) 
   {
	   return ERROW;
   }
   else
   {
       return OK;
   }
} 
int main()
{
    SqStack s;//
    LinkQueue q;
	InitStack(s);
    InitQueue(q);
	char *array1=new char[100];
	cout<<"输入你所要验证的字符串：";
	if(huiwen(s,q))
	{
		cout<<"这是回文";
	}
	else
	{
		cout<<"这不是回文";
	}
	return 0;
}</span>

         输入的字符串为：abcba@

         输出的结果为：

 

         输入的字符串为：abcde@

         输出的结果为：