队列操作 数组实现 链表实现

一、数组实现

/*************************************************************************
 > File Name: array_queue.h
 > Author:  jinshaohui
 > Mail:    jinshaohui789@163.com
 > Time:    18-10-12
 > Desc:    
 ************************************************************************/
#ifndef ARRAY_QUEUE_H
#define ARRAY_QUEUE_H

typedef struct _array_queue
{
    int size;/*队列的大小*/
    int num; /*当前存储数据的大小*/
    int head;/*队列的头*/
    int tail;/*队列的尾*/
    int *array;/*数据存储区*/
}array_queue;

#define array_queue_is_empty(array_queue) (array_queue->num == 0)
#define array_queue_is_full(array_queue)  ((array_queue->num) == (array_queue->size))

#endif

/*************************************************************************
 > File Name: array_queue.c
 > Author:  jinshaohui
 > Mail:    jinshaohui789@163.com
 > Time:    18-10-12
 > Desc:    
 ************************************************************************/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include"./array_queue.h"

array_queue * array_queue_create(int size)
{
    array_queue * queue = NULL;

    queue = (array_queue*)malloc(sizeof(array_queue));
    if (queue == NULL)
    {
        return NULL;
    }
    queue->array = (int *)malloc(sizeof(int)*size);
    if (queue->array == NULL)
    {
        free(queue);
        return NULL;
    }
    queue->size  = size;
    queue->num   = 0;
    queue->head  = 0;
    queue->tail  = 0;

    return queue;
}

void array_queue_destory(array_queue *queue)
{
    if (queue == NULL)
    {
        return;
    }

    if (queue->array != NULL)
    {
        free(queue->array);
    }

    free(queue);
    return;
}

/*入队列 */
int array_queue_enqueue(array_queue *queue,int data)
{
    /*队列为空，或者队列满时，返回-1*/
    if ((queue == NULL) || (array_queue_is_full(queue)))
    {
        return -1;
    }

    queue->num++;
    queue->array[queue->tail] = data;
    queue->tail = (queue->tail + 1) % queue->size;

    return 0;
}

/*出队列*/
int array_queue_dequeue(array_queue * queue,int *data)
{
    /*队列为空，数据存储为空，队列为空时返回-1*/
    if ((queue == NULL) || (data == NULL) || (array_queue_is_empty(queue)))
    {
        return -1;
    }
    *data = queue->array[queue->head];
    queue->num--;
    queue->head = (queue->head + 1) % queue->size;

    return 0;
}

void array_queue_dump(array_queue *queue)
{
    int i = 0;
    int pos = 0;

    if ((queue == NULL) || (array_queue_is_empty(queue)))
    {
        printf("\r\n queue is empty");
        return;
    }

    printf("\r\n size:%d,num:%d,head:%d,tali:%d",
            queue->size,queue->num,queue->head,queue->tail);
    for (i = 0; i < queue->num; i ++)
    {
        pos = (queue->head + i) %queue->size;
        printf("\r\n array[%d] = %d",pos,queue->array[pos]);
    }
    return;
}

int main()
{
    int i = 0;
    int ret = 0;
    int data = 0;
    array_queue * queue = NULL;

    queue = array_queue_create(4);
    if (queue == NULL)
    {
        printf("\r\n queue is create failed.");
        return 0;
    }
    /*队列时空时，出队返回错误*/
    ret = array_queue_dequeue(queue, &data);
    if (ret != 0)
    {
            printf("\r\n queue %d dequeue failed.",ret);
    }

    /*队列大小是4，入队5个，最后一个报错*/
    for (i = 0; i < 5; i++)
    {
        ret = array_queue_enqueue(queue,i);
        if (ret != 0)
        {
            printf("\r\n queue %d enqueue failed.",i);

        }
    }

    array_queue_dump(queue);
    
    ret = array_queue_dequeue(queue, &data);
    if (ret != 0)
    {
            printf("\r\n queue %d dequeue failed.",i);
    }
    printf("\r\n queue %d dequue.",data);
    array_queue_dump(queue);
    data = 5;
    printf("\r\n queue %d enqueue.",data);
    ret = array_queue_enqueue(queue,data);
    if (ret != 0)
    {
        printf("\r\n queue %d enqueue failed.",data);
    }
    array_queue_dump(queue);
    
    array_queue_destory(queue);
    return 0;

}

二、链表实现

/*************************************************************************
 > File Name: list_queue.h
 > Author:  jinshaohui
 > Mail:    jinshaohui789@163.com
 > Time:    18-10-13
 > Desc:    
 ************************************************************************/

#ifndef LINK_LIST_QUEUE_H
#define LINK_LIST_QUEUE_H

typedef struct _list_queue_node
{
    int data;
    struct _list_queue_node *next;
}queue_node;

typedef struct _list_queue
{
    int num;
    queue_node *head;
    queue_node *tail;
}list_queue;

#define list_queue_is_empty(queue) ((queue->num) == 0)

#endif

/*************************************************************************
 > File Name: list_queue.c
 > Author:  jinshaohui
 > Mail:    jinshaohui789@163.com
 > Time:    18-10-13
 > Desc:    
 ************************************************************************/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"./list_queue.h"

/*创建队列头*/
list_queue *list_queue_create()
{
    list_queue * queue = NULL;

    queue = (list_queue *)malloc(sizeof(list_queue));
    if(queue == NULL)
    {
        return NULL;
    }

    queue->num  = 0;
    queue->head = NULL;
    queue->tail = NULL;

    return queue;
}
void list_queue_destroy(list_queue*queue)
{
    int i = 0;
    int data = 0;

    if ((queue == NULL) || (list_queue_is_empty(queue)))
    {
        return ;
    }

    while(!list_queue_is_empty(queue))
    {
        (void)list_queue_dequeue(queue,&data);
    }

    free(queue);
    return;
}
int list_queue_enqueue(list_queue *queue,int data)
{
    queue_node *ptmp = NULL;

    if(queue == NULL)
    {
        return -1;
    }

    ptmp = (queue_node *)malloc(sizeof(queue_node));
    if (ptmp == NULL)
    {
        return -1;
    }

    ptmp->data = data;
    ptmp->next = NULL;
    if (queue->head == NULL)
    {
        queue->head = ptmp;
    }
    else
    {
        queue->tail->next = ptmp;

    }
    queue->tail = ptmp;
    queue->num++;

    return 0;
}

/*出队*/
int list_queue_dequeue(list_queue *queue,int *data)
{
    queue_node * ptmp = NULL;

    if ((queue == NULL) || (data == NULL) || list_queue_is_empty(queue))
    {
        return -1;
    }

    *data = queue->head->data;
    ptmp = queue->head;
    queue->head = queue->head->next;
    queue->num--;

    if (queue->head == NULL)
    {
        queue->tail = NULL;
    }

    
    free(ptmp);
    return 0;
}
void list_queue_dump(list_queue*queue)
{
    int i = 0;
    queue_node *ptmp = NULL;

    if ((queue == NULL) || (list_queue_is_empty(queue)))
    {
        return;
    }

    ptmp = queue->head;

    printf("\r\n----dump queue num = %d--------",queue->num);
    while(ptmp != NULL)
    {
        printf("\r\nnode[%d] = %d",i,ptmp->data);
        i++;
        ptmp = ptmp->next;
    }
    printf("\r\n---------------------------------\r\n");
    
    return;
}

int main()
{
    int i = 0;
    int data = 0;
    int ret = 0;
    list_queue * queue;

    queue = list_queue_create();
    if (queue == NULL)
    {
        printf("\r\nlist queue create falied..");
        return 0;
    }

    for (i = 0; i < 5; i++)
    {
        (void)list_queue_enqueue(queue,i);
    }
    list_queue_dump(queue);

    ret = list_queue_dequeue(queue,&data);
    if(ret != 0)
    {
        printf("\r\nlist queue dequeue %d falied.",data);
    }
    printf("\r\nlist queue dequeue %d",data);
    list_queue_dump(queue);

    ret = list_queue_dequeue(queue,&data);
    if(ret != 0)
    {
        printf("\r\nlist queue dequeue %d failed.",data);
    }
    printf("\r\nlist queue dequeue %d",data);
    list_queue_dump(queue);

    printf("\r\nlist queue enqueue %d",data);
    (void)list_queue_enqueue(queue,data);
    list_queue_dump(queue);

    list_queue_destroy(queue);
    return 0;
}