链队列代码及应用

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>

#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define TRUE 1
#define FALSE 0

typedef int Status;
typedef int ElemType;
typedef struct Qnode{
  int data;
  struct Qnode *next;
} Qnode,*Qlink;

typedef struct {
  Qlink front;
  Qlink rear;
} Queue;

Status initQueue(Queue *Q){
  Q->front = Q->rear = (Qlink)malloc(sizeof(Qnode));
  Q->front->next = NULL;
  return OK;
}

Status isEmpty(Queue Q){
  if(Q.front == Q.rear)return TRUE;
  else return FALSE;
}

Status enQueue(Queue *Q,ElemType e){
  Qlink new = (Qlink)malloc(sizeof(Qnode));
  new->data = e;
  new->next = NULL;
  Q->rear->next = new;
  Q->rear = new;
  return OK;
}


Status deQueue(Queue *Q,ElemType *e){
  if(isEmpty(*Q))return ERROR;
  Qlink tmp = Q->front->next;
  Q->front->next = tmp->next;
  *e = tmp->data;
  if(Q->rear == tmp)Q->rear = Q->front;
  free(tmp);
  return OK;
}

Status destoryQueue(Queue *Q){
  while(Q->front != NULL){
    Q->rear = Q->front->next;
    free(Q->front);
    Q->front=Q->rear;
  }
  return OK;
}


int main(){
  int val;
  char sel;
 
  Queue Q;
  initQueue(&Q);
 
  while(1){
    printf("enter you choose[e|d|D]:");
    sel = getchar();

    if(sel == ‘e‘){
      printf("enter value:");
      scanf("%d",&val);
      enQueue(&Q,val);
    }

    else if(sel == ‘d‘){
      deQueue(&Q,&val);
      printf("value is %d\n",val);
      sleep(1);
    }
 
    else if(sel == ‘D‘){
      destoryQueue(&Q);
    }
  }
}

#include <stdio.h>
#include <stdlib.h>

#define OK 1
#define ERROR 0
#define STACK_MAX 100
#define QUEUE_MAX 100

typedef char ElemType;
typedef int  Status;

typedef struct{
  ElemType * base;
  ElemType * top;
} Stack;

typedef struct{
  ElemType *base;
  int front;
  int rear;
} Queue;

//****************************
//      stack library
//****************************
Status initStack(Stack *s){
  s->base = (ElemType*)malloc(STACK_MAX * sizeof(ElemType));
  s->top = s->base;
  return OK;
}

Status pushStack(Stack *s,ElemType e){
  if(s->top - s->base ==STACK_MAX)return ERROR;
  *s->top=e;
  s->top++;
  return OK;
}

Status popStack(Stack *s,ElemType *e){
  if(s->top - s->base == 0)return ERROR;
  *e = *(--s->top);
  return OK;
}


//****************************
//       queue library
//****************************
Status initQueue(Queue *q){
  q->base = (ElemType*)malloc(QUEUE_MAX * sizeof(ElemType));
  q->front = q->rear = 0;
  return OK;
}

Status enQueue(Queue *q,ElemType e){
  if(q->rear+1%QUEUE_MAX==q->front)return ERROR;
  *(q->base + q->rear) = e;
  q->rear = q->rear+1%QUEUE_MAX;
  return OK;
}

Status deQueue(Queue *q,ElemType *e){
  if((q->rear-q->front+QUEUE_MAX)%QUEUE_MAX==0)
    return ERROR;
  *e = *(q->base + q->front);
  q->front = (q->front+1)%QUEUE_MAX;
  return OK;
}

Status checkPalindrome(char *str){
  char c1,c2;
  char *p = str;

  Stack S;
  Queue Q;
 
  //init
  initStack(&S);
  initQueue(&Q);
 
  //input
  while(*p!=‘\n‘){
    pushStack(&S,*p);
    enQueue(&Q,*p);
    p++;
  }

  //output
  while(S.top!=S.base){
    popStack(&S,&c1);
    deQueue(&Q,&c2);
    if(c1!=c2)return ERROR;
  }

  return OK;
}

int main(){
   char test[100];
   printf("This is check sentence if it is palindarome\n");
   printf("enter the Ctrl + C to exit programe\n");
   while(1){
     printf("enter a string:");
     fgets(test,100,stdin);
     if(checkPalindrome(test))
       printf("yes,it is\n");
     else
       printf("no,it isn‘t\n");
   }
}