編寫一個演算法，判斷任意給定的字元序列是否為迴文。所謂迴文是指一個把字元序列的中間字元作為基準，兩字元完全相同，即從兩個方向看，都是相同的字元序列。

例如，字元序列“ABCDEFEDCBA”為迴文，而字元序列“xabcdcaax”不是迴文。

【分析】

這個題目考察對棧的“後進先出”思想和佇列的“先進先出”思想理解及應用，判斷是否為迴文可通過構造棧和佇列來實現。具體做法是：可以先把一個字元序列分別入隊和入棧，然後將字元出隊和出棧，這是利用了出隊的順序和出棧的順序剛好相反，同時比較出隊的字元和出棧的字元是否相等，若相等，則繼續取出佇列和棧中的下一個字元進行比較，直到棧和佇列為空，表明該字元序列為迴文；若有字元不相等，則該字元不是迴文。

LinkQueue.h

#pragma once
#include <iostream>
using namespace std;
#include <malloc.h>
typedef char DataType;
typedef struct QNode
{
	DataType data;
	struct QNode* next;

}LQNode,*QueuePtr;
typedef struct 
{
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;
//初始化鏈式佇列
void InitQueue(LinkQueue *LQ)
{
	LQ->front = LQ->rear = (LQNode*)malloc(sizeof(LQNode));
	if (LQ->front==NULL)
	{
		exit(-1);
	}
	LQ->front->next = NULL;

}
//判斷鏈式佇列是否為空
int QueueEmpty(LinkQueue LQ)
{
	if (LQ.rear->next==NULL)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}
//將元素e入隊
int EnQueue(LinkQueue *LQ, DataType e)
{
	LQNode *s;
	s = (LQNode*)malloc(sizeof(LQNode));
	if (!s)
	{
		exit(-1);
	}
	s->data = e;
	s->next = NULL;
	LQ->rear->next = s;
	LQ->rear = s;
	return 1;
}

int DeQueue(LinkQueue *LQ, DataType *e)
{
	LQNode *s;
	if (LQ->front==LQ->rear)
	{
		return 0;
	}
	else
	{
		s = LQ->front->next;
		*e = s->data;
		LQ->front->next = s->next;
		if (LQ->rear==s)
		{
			LQ->rear = LQ->front;
		}
		free(s);
		return 1;
	}
}

int GetHead(LinkQueue LQ, DataType *e)
{
	LQNode *s;
	if (LQ.front==LQ.rear)
	{
		return 0;
	}
	else
	{
		s = LQ.front->next;
		*e = s->data;
		return 1;
	}
}

void ClearQueue(LinkQueue *LQ)
{
	while (LQ->front!=NULL)
	{
		LQ->rear = LQ->front->next;
		free(LQ->front);
		LQ->front = LQ->rear;
	}
}
 

LinkStack.h

#pragma once
#include <iostream>
#include <malloc.h>

using namespace std;
typedef char DataType;
typedef struct node 
{
	DataType data;
	struct node *next;
}LStackNode,*LinkStack;


void InitStack(LinkStack *top)
{
	if ((*top=(LinkStack)malloc(sizeof(LStackNode)))==NULL)
	{
		exit(-1);
	}
	(*top)->next = NULL;
}

int StackEmpty(LinkStack top)
{
	if (top->next==NULL)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

int PushStack(LinkStack top, DataType e)
{
	LStackNode *p;
	if ((p=(LStackNode*)malloc(sizeof(LStackNode)))==NULL)
	{
		cout << "記憶體分配失敗！";
		exit(-1);
	}
	p->data = e;
	p->next = top->next;
	top->next = p;
	return 1;
}

int PopStack(LinkStack top, DataType *e)
{
	LStackNode *p;
	p = top->next;
	if (!p)
	{
		cout << "棧已空！";
		return 0;
	}
	top->next = p->next;
	*e = p->data;
	free(p);
	return 1;
}

int GetTop(LinkStack top, DataType *e)

{
	LStackNode *p;
	p = top->next;
	if (!p)
	{
		cout << "棧已空！";
		return 0;
	}

	*e = p->data;
	return 1;
}

int StackLength(LinkStack top)
{
	LStackNode *p;
	int count = 0;
	p = top;
	while (p->next!=NULL)
	{
		p = p->next;
		count++;

	}
	return count;
}

void DestoryStack(LinkStack top)
{
	LStackNode *p, *q;
	p = top;
	while (!p)
	{
		q = p;
		p = p->next;
		free(q);

	}
}
 

main.cpp

#include "LinkQueue.h"
#include "LinkStack.h"
#include <string.h>
#include <stdlib.h>
#include <iomanip>
typedef char DataType;

void PrintStackQueue(LinkStack LStack,LinkQueue LQueue);

void main()
{
	DataType str1[] = "ABCDEFEDCBA";
	DataType str2[] = "xabcdcaax";
	int i;
	LinkQueue LQueue1, LQueue2;
	LinkStack LStack1, LStack2;
	InitQueue(&LQueue1);
	InitQueue(&LQueue2);
	InitStack(&LStack1);
	InitStack(&LStack2);

	for (i = 0; i < strlen(str1);i++)
	{
		EnQueue(&LQueue1, str1[i]);
		PushStack(LStack1, str1[i]);
	}

	for (i = 0; i < strlen(str2);i++)
	{
		EnQueue(&LQueue2, str2[i]);
		PushStack(LStack2, str2[i]);
	}


	cout << "字元序列1：" << str1 << endl;
	PrintStackQueue(LStack1, LQueue1);
	cout << "字元序列2：" << str2 << endl;
	PrintStackQueue(LStack2, LQueue2);


	system("pause");
}


void PrintStackQueue(LinkStack LStack, LinkQueue LQueue)
{
	DataType st, qu;
	cout << "出隊序列     出棧序列" << endl;
	while (!StackEmpty(LStack))
	{
		DeQueue(&LQueue, &qu);
		PopStack(LStack, &st);
		cout << setw(5) << qu;
		cout << setw(10) << st << endl;
		if (qu!=st)
		{
			cout << "該字元序列不是迴文！" << endl;
			return;
		}
	}
	cout << "該字元序列是迴文！" << endl;
}

結果：