队列设计与实现（包含顺序队列和链式队列）

队列：是一种先进先出  FIFO  后进后出  LILO 的数据管理方式。

队列设计实现方式：

1.顺序队列/环形队列（数据存储使用数组方式）

  类型定义：

typedef int data_t;
typedef struct
{
  data_t *pData;
  int  size;//数组容量
  int  head;//头指针
  int  tail;//尾指针
}squeue_t;

相关功能算法:

 创建队列：

int SQeue_Create(squeue_t *q,int sz)
{
  q -> data = (data_t*)calloc(sizeof(data_t),sz);
  if(q -> PData == NULL)
     return -1;
  q -> size = sz;
  q -> head = q -> tail = 0;
  
  return 0;
}

判断队列是否满：

int SQueue_isfull(squeue_t* q)
{
    return  (q -> tail + 1) % (q -> size)  == q -> head;
}

判断队列是否空：

int SQueue_isempty(squeue_t* q)
{
    return q -> head == q -> tail;
}

入队（用tail尾指针，尾插法）：

int SQueue_Push(squeue_t* q,Data_t data)
{
   if(q == NULL)
       return -1;
   if(SQueue_isfull(q))
       return -1;

   q -> pData[q -> tail] = data;
   q -> tail = (q -> tail + 1) % (q -> size);
   return 0;
}

出队（用head指针，从头部出）：

int SQueue_Pop(squeue_t* q,Data_t* data)
{
    if(q == NULL)
       return -1;
    if(SQueue_isempty(q))
       return -1;
    
    *data = q->pData[q->head];
    q -> head = (q ->head +1) % (q -> size);
    return 0;
}

释放：

void SQueue_free(squeue_t* q)
{
    if(q == NULL)
       return ;
    if(q -> pData)
    {
        free(q ->pData);
        q -> pData = NULL;
    } 
    q -> size  = 0;
    q -> head  = q -> tail = 0;
}

2.链式队列（数据存储采用链表方式）

类型定义：

typedef  node_t*  Data_t;
typedef  struct node
{
    Data_t         data;
    struct node   *next;
}Node_t;

typedef  struct
{
  Node_t     *head;
  Node_t     *tail;
  int         size ;
  int         count  ;//当前队列的结点数量
}LQueue_t;

创建队列：

int LQueue_Create(LQueue_t* q,int sz)
{
    if(q == NULL)
      return -1;
    
    q -> head  = q -> tail = NULL;
    q -> size  = sz;
    q -> count = 0;
   
    return 0;   
}

判断队列是否满：

int LQueue_isfull(LQueue_t* q)
{
    return q -> count == q -> size;
}

判断队列是否空：

int LQueue_isempty(LQueue_t* q)
{
    return q -> count == 0;
}

入队：

int LQueue_Push(LQueue_t* q,Data_t data)
{
    if(q == NULL)
        return -1;
    if(LQueue_isfull(q))
        return -1;

    Node_t *p  = (Node_t*)malloc(sizeof(Node_t));
    if(p == NULL)
        return -1;
    p -> data  = data;
    p -> next  = NULL;

    if(q -> tail == NULL)
    {
        q -> head = q -> tail = p;
    }
    else
    {
       q -> tail -> next = p;
       q -> tail  = p;
    }
    q -> count ++;

    return 0;
}

出队：

int LQueue_Pop(LQueue_t* q,Data_t* data)
{
    if(q == NULL)
        return -1;
    if(LQueue_isempty(q))
        return -1;

    Node_t *p  = q -> head;
    q -> head  = p -> next;
    *data      = p -> data;
    free(p);
    q -> count --;
    return 0;
}

释放：

void LQueue_free(LQueue_t* q)
{
    if(q == NULL)
       return ;
   
    Node_t *f = q -> head, *b  = NULL ;
    while(f)
    {
         b  = f;
         f  = f -> next;
         free(b);
    }
    q -> head  = q -> tail = NULL;
    q -> count = 0;
    q -> size  = 0;   
}