栈与队列——判断回文字符串

1、编程序判断一个字符序列是否是回文，要求采用链式队列和链式堆栈。

提示：设字符数组str中存放了要判断的字符串。把字符数组中的字符逐个分别存入队列和堆栈，然后逐个出队列和退栈并比较出队列的字符和退栈的字符是否相等，若全部相等则该字符序列是回文，否则就不是回文。

以下是程序部分代码，请调试并补充使之正确运行。

1、队列的头文件

#include<stdio.h>  
#include<stdlib.h>
#include<malloc.h>
typedef struct qnode
{
	char data;
	struct qnode *next;
} LQNode,*PLQNode; 						

typedef struct
{
	LQNode *front;							/*队头指针*/
	LQNode *rear;							/*队尾指针*/
} LQueue,*PLQueue;

void QueueInitiate(LQueue *Q)				/*初始化链式队列Q*/
{
	Q->rear = NULL;					/*定义初始队尾指针下标值*/	
	Q->front = NULL;					/*定义初始队头指针下标值*/	
}
void DestroyQ(LQueue Q)
{
	LQNode *p, *p1;

	p = Q.front;
	while(p != NULL)
	{
		p1 = p;
		p = p->next;
		free(p1);
	}
}
int QueueNotEmpty(LQueue Q)
/*判链式队列Q非空否，非空则返回1，否则返回0*/
{
	if(Q.front == NULL) return 0;
	else return 1;
}

int QueueAppend(LQueue *Q, char x)
/*把数据元素值x插入链式队列Q的队尾，入队列成功则返回1，否则返回0 */
{
	LQNode *p;
	if((p = (LQNode *)malloc(sizeof(LQNode))) == NULL) 
	{
		printf("内存空间不足！");
		return 0;
	}
	
	p->data = x;
	p->next = NULL;
	
	if(Q->rear != NULL) Q->rear->next = p;
	Q->rear = p;
	if(Q->front == NULL) Q->front = p;
	return 1;
}

int QueueDelete(LQueue *Q, char *d)
/*删除链式队列Q的队头数据元素值到d ，出队列成功则返回1，否则返回0*/
{
	LQNode *p;
	if(Q->front == NULL)
	{
		printf("队列已空无数据元素出队列! \n");
		return 0;
	}
	else
	{
		*d = Q->front->data;
		p = Q->front;
		Q->front = Q->front->next;
		if(Q->front == NULL) Q->rear = NULL;
		free(p);
		return 1;
	}
}

int QueueGet(LQueue Q, char *d)
/*取链式队列Q的当前队头数据元素值到d ，成功则返回1，否则返回0*/
{
	if(Q.front == NULL)
	{
		printf("队列已空无数据元素出队列! \n");
		return 0;
	}
	else
	{
		*d = Q.front->data;
		return 1;
	}
}

2、栈的头文件

#include<stdio.h>  
#include<stdlib.h>
#include<malloc.h>
typedef struct snode
{
	char data;
	struct snode *next;
} LSNode,*PLSNode;

void StackInitiate(LSNode **head)//传入一个结构体指针的指针（栈的头结点），为栈开辟空间 
/*初始化带头结点链式堆栈*/
{
	if((*head = (LSNode *)malloc(sizeof(LSNode))) == NULL)
	{
		printf("没有空间申请\n");
    	return;
	}
	(*head)->next = NULL;
}

int StackNotEmpty(LSNode *head)
 /*判堆栈是否非空，非空返回1；空返回0*/
{
	if(head->next == NULL) return 0;
	else return 1;
}

int StackPush(LSNode *head, char x) 
/*把数据元素x插入链式堆栈head的栈顶作为新的栈顶 */
{
	LSNode *p;

	if((p = (LSNode *)malloc(sizeof(LSNode))) == NULL)
	{
		printf("内存空间不足无法插入! \n");
		return 0;
	}

	p->data = x;
	p->next = head->next;				/*新结点链入栈顶*/
	head->next = p; 					/*新结点成为新的栈顶*/
	return 1;
}

int StackPop(LSNode *head, char *d)
/*出栈并把栈顶元素由参数d带回*/
{
	LSNode *p = head->next;
	if(p == NULL) 
	{
		printf("堆栈已空出错！");
		return 0;
	}

	head->next = p->next;			/*删除原栈顶结点*/
	*d = p->data; 					/*原栈顶结点元素赋予d*/
	free(p); 						/*释放原栈顶结点内存空间*/
	return 1;
}

int StackTop(LSNode *head, char *d)
 /*取栈顶元素并把栈顶元素由参数d带回*/
{
	LSNode *p = head->next;
	if(p == NULL) 
	{
		printf("堆栈已空出错！");
		return 0;
	}
	*d = p->data;
	return 1;
}

void DestroyL(LSNode *head)
{
	LSNode *p, *p1;

	p = head;
	while(p != NULL)
	{
		p1 = p;
		p = p->next;
		free(p1);
	}
}

3、测试文件

#include<stdio.h>  
#include<stdlib.h>
#include<malloc.h>
#include"LinStack.h"
#include"LinQueue.h"
int i;
void HuiWen(char str[])
{
   //第一步：将str依次存到栈中
	PLSNode PStack = (PLSNode)malloc(sizeof(LSNode));
	StackInitiate(&PStack);
	for(i=0;str[i]!='\0'&&StackPush(PStack, str[i])==1;i++);
	//第二步：将str依次存到队列中
	PLQueue PQ = (PLQueue)malloc(sizeof(LQueue));
	QueueInitiate(PQ);
	for(i=0;str[i]!='\0'&&QueueAppend(PQ, str[i])==1;i++);
	//第三步：依次弹出比较 
	char c1,c2;
	for(i=0;str[i]!='\0';i++){
		QueueDelete(PQ,&c1);
		StackPop(PStack,&c2);
		if(c1!=c2){
			printf("不是回文数\n"); 
			DestroyQ(*PQ);
			DestroyL(PStack);
			return;
		}	
	}

	printf("是回文数\n");
	DestroyQ(*PQ);
	DestroyL(PStack);

}

void main(void)
{
	char str1[]="abcdedcba";
	char str2[]="ABCDEABCDE";
	HuiWen(str1);
	HuiWen(str2);
}