栈和队列——实现回文函数

通过栈的先进后出特性和队列先进先出的特性可以同时进行存储，然后取出数据，最后比较两部分数据是否相等，如果相等，则可以认为此数字是回文数据而已。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<malloc.h>
typedef char DataType;
//链式堆栈结点类型定义
typedef struct snode{
	DataType data;
	struct snode *next;
}LSNode;
//只有队尾指针的链式循环队列类型定义 
typedef struct QNode{
	DataType data;
	struct QNode *next;
}LQNode,*LinkQueue; 
//带头结点的链式堆栈初始化
void InitStack(LSNode **head){
	if((*head=(LSNode*)malloc(sizeof(LSNode)))==NULL)//为头结点分配空间
	{
		printf("分配结点不成功");
		exit(-1);
	 } 
	 else{
	 	(*head)->next=NULL;//为头结点的指针域 
	 }
} 
//判断带头结点的链式堆栈是否为空。如果堆栈为空，返回1，否则返回0
int StackEmpty(LSNode *head){
	if(head->next==NULL){
		return 1;
	}else{
		return 0;
	}
} 
//链式堆栈进栈 。 进栈成功返回1，否则退出
int PushStack(LSNode *head,DataType e){
	LSNode *s;
	s=(LSNode*)malloc(sizeof(LSNode)); 
	if(!s){
		exit(-1);
	}
	s->data=e;
	s->next=head->next;
	head->next=s;
	return 1;
} 
//链式堆栈出栈，需要判断堆栈是否为空，出栈为空返回1，否则返回0
int PopStack(LSNode *head,DataType *e){
	LSNode *s=head->next;
	if(StackEmpty(head)){
		return 0;
	}else{
		head->next=s->next;
		*e=s->data;
		free(s);
		return 1; 
	}
} 
//将带头结点的链式循环队列初始化为空队列，需要把头结点的指针指向头结点
void InitQueue(LinkQueue *rear){
	*rear=(LQNode*)malloc(sizeof(LQNode));
	if(*rear==NULL){
	  exit(-1);
	}else{
		(*rear)->next=*rear;
	}
} 
//判断链式队列是否为空，队列为空返回为1，否则返回0
int QueueEmpty(LinkQueue rear){
	if(rear->next==rear){
		return 1;
	} else{
		return 0;
	}
}
//将元素e 插入到链式队列中，插入成功返回1
int EnQueue(LinkQueue *rear,DataType e){
	LQNode *s;
	s=(LQNode*)malloc(sizeof(LQNode));
	if(!s){
		exit(-1);
	}
	s->data=e;
	s->next=(*rear)->next; 
	(*rear)->next=s;
	*rear=s;
	return 1;
} 
//删除链式队列中的队头元素，并将元素赋值给e，删除成功后返回1，否则返回0
int DeQueue(LinkQueue *rear,DataType *e){
	LQNode *f,*p;
	if(*rear==(*rear)->next){
	return 0;	
	}else{
		f=(*rear)->next;
		p=f->next;
		if(p==*rear){
			*rear=(*rear)->next;
			(*rear)->next=*rear;
		}else{
			f->next=p->next;
		}
		*e=p->data;
		free(p);
		return 1;
	}
} 
int main(){
	LinkQueue LQueue1,LQueue2;
	LSNode *LStack1,*LStack2;
	char str1[]="XYZAZYX";
	char str2[]="XYZBZXY";
	char q1,s1,q2,s2;
	int i;
	//队列 
	InitQueue(&LQueue1);
	InitQueue(&LQueue2);
	//堆栈 
	InitStack(&LStack1);
	InitStack(&LStack2);
	//存储
	for(i=0;i<strlen(str1);i++){
		//入队 
		EnQueue(&LQueue1,str1[i]);
		EnQueue(&LQueue2,str2[i]);
		//进栈 
		PushStack(LStack1,str1[i]);
		PushStack(LStack2,str2[i]);
	} 
	printf("字符序列1：\n");
	printf("出队序列 出栈序列\n");
	while(!StackEmpty(LStack1)){
		DeQueue(&LQueue1,&q1);
		PopStack(LStack1,&s1);
		printf("%5c",q1);
		printf("%10c\n",s1);
		if(q1!=s1){
			printf("字符序列1不是回文！");
			return 0; 
		}
	}
	printf("字符序列1是回文\n");
	printf("字符序列2：\n");
	printf("出队序列 出栈序列\n");
	while(!StackEmpty(LStack2)){
		DeQueue(&LQueue2,&q2);
		PopStack(LStack2,&s2);
		printf("%5c",q2);
		printf("%10c\n",s2);
		if(q2!=s2){
			printf("字符序列2不是回文！");
			return 0; 
		}
	}
	printf("字符序列2是回文\n");
	return 1;

}

动态输入回文数：

此代码为引用代码，非本人所写。

#include <stdio.h> 
#include<stdlib.h> 
#define m 100 
 
typedef struct          //定义栈
 { 
  char data[m]; 
  int  top; 
}zhan;    

void cshz(zhan *s)      //初始化栈
{ 
  s->top=0; 
}                         

int pdzk(zhan *s)        //判断栈是否为空
{ 
  if(s->top==0)                         
  { 
    return 0; 
  } 
  else 
  { 
    return 1; 
  }              
}                        

void ruzhan(zhan *s,char x)  //入栈
{ 
  if(s->top==m)                       
   { 
     printf("栈空\n"); 
  }                         
  else                                   
   {               
     s->data[++s->top]=x;                
   } 
}                       

char chuzhan(zhan *s)        //出栈
{ 
  char y; 
  if(s->top==0)                         
  
  { 
    printf("栈空\n");    
    return '0';   
  }
  else                                 
  {     
    y=s->data[s->top];                   
    s->top=s->top-1;                       
    return y; 
  } 
}                   

typedef struct {          //定义队列
 char data[m]; 
 int  front; 
 int  rear; 
}dui;  

 void cshdl(dui *q)      //初始化队列
{ 
  q->front=q->rear=0;                            
}                          
 
void rudui(dui *q,char e)            //入队
{
  if((q->rear+1)%m==q->front)           
   { 
    printf("队列为空\n"); 
   } 
   else 
   { 
    q->data[q->rear]=e;                
    q->rear=(q->rear+1);             
   } 
}                     
 
char chudui(dui *q)         //出对
{ 
  char f; 
  if(q->front==q->rear)                 
   { 
     printf("队列为空\n");    
     return 0; 
   } 
   else 
   { 
     f=q->data[q->front];   
	 q->front=(q->front+1);            
     return f; 
   } 
}                  
  
int  main()             
{                                 
  char c; 
  int y=0; 
  zhan *s=(zhan *)malloc(sizeof(zhan)); 
  dui *q=(dui *)malloc(sizeof(dui)); 
  cshz(s);   
  cshdl(q); 
  printf("输入一个字符串:\n");
  while((c=getchar())!='@') 
  {
    ruzhan(s,c);            
    rudui(q,c); 
  } 
  while(pdzk(s))          
   { 
     if(chuzhan(s)==chudui(q)) 
     { 
      y=1;                 
      continue;            
     } 
     else                   
     { 
      y=0; 
      break;                 
     } 
   } 
   if(y==1) 
    printf("此字符串为回文\n"); 
  else 
    printf("此字符串不是回文\n");
  return 0;
}