链式表示的队列——链式队列3——判断是否为回文

编写一个算法，判断任意给定的字符序列是否为回文。所谓回文是指一个把字符序列的中间字符作为基准，两字符完全相同，即从两个方向看，都是相同的字符序列。

例如，字符序列“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;
}

结果：

链式表示的队列——链式队列3——判断是否为回文

猜你喜欢