队列 c实现

循环队列的数组实现

queue.h

#ifndef _QUEUE_H_
#define _QUEUE_H_

#define SIZE 10

typedef int data_t;

typedef struct head{
        data_t data[SIZE];
        int front;
        int rear;
}queue_t;

queue_t *queue_creat();

int queue_is_empty(queue_t *head);
int queue_is_full(queue_t *head);
void queue_clear(queue_t *head);

int queue_en(queue_t *head,data_t data);
data_t queue_de(queue_t *head);

void queue_show(queue_t *head);
void queue_destory(queue_t **head);

#endif //_QUEUE_H_

queue.c

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

#include "queue.h"

queue_t *queue_create()
{
    queue_t *head = (queue_t *)malloc(sizeof(queue_t));
    bzero(head, sizeof(queue_t));

    head->front = 0;
    head->rear = 0;

    return head;
}

int queue_is_empty(queue_t *head)
{
    return head->front == head->rear;
}

int queue_is_full(queue_t *head)
{
    return head->rear - head->front == SIZE;
}

void queue_clear(queue_t *head)
{
    head->rear = head->front;
}

int queue_en(queue_t *head, data_t data)
{
    if (queue_is_full(head)) {
        printf("queue is full!
");
        return -1;
    }

    head->data[head->rear % SIZE] = data;
    head->rear++;

    return 0;
}

data_t queue_de(queue_t *head)
{
    if (queue_is_empty(head)) {
        printf("queue is empty!
");
        return -1;
    }

    data_t data = head->data[head->front % SIZE];
    head->front++;

    return data;
}

void queue_show(queue_t *head)
{
    int i;
    for (i = head->front; i < head->rear; i++) {
        printf("%d, ", head->data[i % SIZE]);
    }
    printf("
");
}

void queue_destory(queue_t **head)
{
    free(*head);
    *head = NULL;
}

main.c

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

#include "queue.h"

int main()
{
    queue_t *head = queue_create();

    int n = 10;
    while (n--) {
        queue_en(head, n+1);
    }
    queue_show(head);

    int i;
    for (i = 0; i < 5; i++) {
        printf("%d, ", queue_de(head));
    }
    printf("
");
    queue_show(head);

    for (i = 20; i < 25; i++) {
        queue_en(head, i);
    }
    queue_show(head);

    queue_destory(&head);

    return 0;
}

 队列的链表实现

queue.h

#ifndef _QUEUE_
#define _QUEUE_

typedef int data_t;

typedef struct node{
    data_t data;
    struct node *next;
}NODE;

typedef struct{
    struct node *front;
    struct node *rear;
}queue_t;

queue_t *queue_create();

int queue_is_empty(queue_t *head);
int queue_is_full(queue_t *head);
void queue_clear(queue_t *head);

int queue_en(queue_t *head, data_t data);
data_t queue_de(queue_t *head);

void queue_show(queue_t *head);
void queue_destory(queue_t **head);

#endif

 queue.c

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

#include "queue.h"

queue_t *queue_create()
{
    queue_t *head = (queue_t *)malloc(sizeof(queue_t));
    bzero(head, sizeof(queue_t));

    head->front = (NODE *)malloc(sizeof(NODE));
    bzero(head->front, sizeof(NODE));

    head->front->data = -1;
    head->front->next = NULL;

    head->rear = head->front;

    return head;
}

int queue_is_empty(queue_t *head)
{
    //return head->front->next == NULL;
    return head->front == head->rear;
}

int queue_is_full(queue_t *head)
{
    return 0;
}

void queue_clear(queue_t *head)
{
    NODE *p = head->front->next;
    NODE *q = p->next;

    head->front->next = NULL;

    while (p != NULL) {
        q = p->next;

        free(p);

        p = q;
    }

    head->rear = head->front;
}

int queue_en(queue_t *head, data_t data)
{
    NODE *p = (NODE *)malloc(sizeof(NODE));
    bzero(p, sizeof(NODE));
    p->data = data;
    p->next = NULL;

    head->rear->next = p;

    head->rear = p;

    return 0;
}

data_t queue_de(queue_t *head)
{
    if (queue_is_empty(head)) {
        printf("queue is empty!
");
        return -1;
    }

    NODE *p = head->front;
    NODE *q = p->next;
    data_t data = q->data;

    p->next = q->next;
    free(q);
    q = NULL;

    if (p->next == NULL) {
        head->rear = head->front;
    }

    return data;
}

void queue_show(queue_t *head)
{
    NODE *p = head->front->next;

    while (NULL != p) {
        printf("%d, ", p->data);
        p = p->next;
    }
    printf("
");
}

void queue_destory(queue_t **head)
{
    queue_clear(*head);

    free(*head);
    *head = NULL;
}

main.c

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

#include "queue.h"

int main()
{
    queue_t *head = queue_create();

    int n = 10;
    while (n--) {
        queue_en(head, n+1);
    }
    queue_show(head);

    int i;
    for (i = 0; i < 5; i++) {
        printf("%d, ", queue_de(head));
    }
    printf("
");
    queue_show(head);

    for (i = 20; i < 25; i++) {
        queue_en(head, i);
    }
    queue_show(head);

    queue_destory(&head);

    return 0;
}