顺序队列和链式队列

queue_seq.h

#pragma once
#define MaxSize 1024
typedef char TypeQueue;


typedef struct SeqQueue
{
    TypeQueue data[MaxSize];
    size_t head;
    size_t tail;
    size_t size;


}SeqQueue;
void SeqQueueInit(SeqQueue* seq);


void SeqQueueDestory(SeqQueue* seq);


void SeqQueuePush(SeqQueue* seq,TypeQueue value);


void SeqQueuePop(SeqQueue* seq);


int SeqQueueTop(SeqQueue* seq,TypeQueue* value);

queue_seq.c

#include<stdio.h>
#include<stdlib.h>
#include"queue_seq.h"
#define TEST_HEADER printf("\n=================%s==================\n",__FUNCTION__)


void SeqQueueInit(SeqQueue* seq)
{
    if(seq==NULL)
    {
        return;
    }
    seq->size=0;
    seq->head=0;
    seq->tail=0;


}


void SeqQueueDestory(SeqQueue* seq)
{
    if(seq==NULL)
   {
       return;
   }


    seq->size=0;
    seq->head=0;
    seq->tail=0;


}


//void Increase_MaxSize(SeqQueue* seq,TypeQueue value)
//{
//     
//}


void SeqQueuePush(SeqQueue* seq,TypeQueue value)
{
    if(seq==NULL)
    {
        return;
    }


    if( (seq->tail + 1) % MaxSize==seq->head)
    {
        printf("The SeqQueue is full!");
        return;
        
    } 


    if( seq->size==0 )
    {
        seq->data[seq->head]=value;
        ++seq->size; 
        return;
    }


      if(seq->tail==MaxSize-1)
      {
          seq->tail=0;
  
      }
      else
      {
  
          ++seq->tail;
      }
      
  
      seq->data[seq->tail]=value;
      ++seq->size;
  


}


void SeqQueuePop(SeqQueue* seq)
{
    if(seq==NULL)
    {
        return;
    }
    if(seq->size==0)
    {
        return;
    }
    if(seq->size==1)
    {
       --seq->size;
       return;
    }


    if(seq->head==MaxSize-1)
    {
        seq->head=0;


    }else{


      ++seq->head;
      


    }
    --seq->size;


}




int SeqQueueTop(SeqQueue* seq,TypeQueue* value)
{
    if(seq==NULL)
    {
        return 0;
    }
    if(seq->size==0)
    {
        return 0;
    }
    
    *value=seq->data[seq->head];
    return 1;
}


void StructShow(SeqQueue* seq)
{
    printf("Seq->top:%c \n",seq->data[seq->head]);
    printf("Seq->head:%d \n",seq->head);
    printf("Seq->tail:%d \n",seq->tail);
    printf("Seq->size:%d \n",seq->size);
    printf("\n");
}
#if TEST 
void Test()
{
  TEST_HEADER;
  size_t i;
  SeqQueue seq;
  TypeQueue value;
  SeqQueueInit(&seq);
  StructShow(&seq);
  SeqQueuePush(&seq,'a');
  SeqQueuePush(&seq,'b');
  SeqQueuePush(&seq,'c');
  SeqQueuePush(&seq,'d');
  StructShow(&seq);
  SeqQueuePop(&seq);
  SeqQueuePop(&seq);
  SeqQueuePop(&seq);
  StructShow(&seq);


  SeqQueuePush(&seq,'c');
  SeqQueuePush(&seq,'d');
  i=SeqQueueTop(&seq,&value);
  printf("ret:%d \n",i);
  printf("value:%c \n",value);


  SeqQueueDestory(&seq);
  StructShow(&seq);


}
int main()
{
    Test();
    return 0;
}
#endif

queue_link.c

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


void Queueinit(Queue* queue)
{
    queue->front=NULL;
    queue->rear=NULL;
}

Node* CreatNode(TypeQueue value)
{
    Node* tmp =(Node*)malloc(sizeof(Node));
    tmp->data=value;
    tmp->next=NULL;
    return tmp;
}

void QueuePush(Queue * queue,TypeQueue value)
{
    if(queue==NULL)
    {
        return;
    }
   if(queue->rear==NULL)
   {

    Node* tmp= CreatNode(value);
    queue->rear=tmp;
    queue->front=tmp;
   }else{

    Node* tmp=CreatNode(value);

    queue->rear->next=tmp;
    queue->rear=queue->rear->next;
   }
}

void QueuePop(Queue * queue)
{
    if(queue==NULL)
    {
        return;
    }
    if(queue->front==NULL)
    {
        return;
    }
    Node* to_delete=queue->front;
    queue->front=queue->front->next;
    free(to_delete);
}

TypeQueue QueueTop(Queue * queue)
{
    if(queue==NULL)
    {
        return 0;
    }
    if(queue->front==NULL)
    {
        return 0;
    }
    return queue->front->data;
}
int main()
{
    return 0;
}