순차적 루프 큐 (순환 큐)

sequeue.h

#define MAX_SIZE 5

typedef int QueueElement;

typedef struct {
    QueueElement elements[MAX_SIZE];
    int head;
    int tail;
} CircularQueue;

CircularQueue* create_queue();
int enqueue(CircularQueue* queue, QueueElement value);
QueueElement dequeue(CircularQueue* queue);
int is_empty(CircularQueue* queue);
int is_full(CircularQueue* queue);
int clear_queue(CircularQueue* queue);
int destroy_queue(CircularQueue* queue);

sequeue.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sequeue.h"

CircularQueue* create_queue() {
    CircularQueue* q = (CircularQueue*)malloc(sizeof(CircularQueue));
    if (!q) {
        fprintf(stderr, "메모리 할당 실패\n");
        return NULL;
    }
    memset(q->elements, 0, sizeof(q->elements));
    q->head = 0;
    q->tail = 0;
    return q;
}

int enqueue(CircularQueue* queue, QueueElement value) {
    if (!queue) {
        fprintf(stderr, "큐가 유효하지 않음\n");
        return -1;
    }
    if ((queue->tail + 1) % MAX_SIZE == queue->head) {
        fprintf(stderr, "큐가 가득 참\n");
        return -1;
    }
    queue->elements[queue->tail] = value;
    queue->tail = (queue->tail + 1) % MAX_SIZE;
    return 0;
}

QueueElement dequeue(CircularQueue* queue) {
    if (!queue) {
        fprintf(stderr, "큐가 유효하지 않음\n");
        return -1;
    }
    if (queue->head == queue->tail) {
        fprintf(stderr, "큐가 비어 있음\n");
        return -1;
    }
    QueueElement result = queue->elements[queue->head];
    queue->head = (queue->head + 1) % MAX_SIZE;
    return result;
}

int is_empty(CircularQueue* queue) {
    if (!queue) return -1;
    return (queue->head == queue->tail) ? 1 : 0;
}

int is_full(CircularQueue* queue) {
    if (!queue) return -1;
    return ((queue->tail + 1) % MAX_SIZE == queue->head) ? 1 : 0;
}

int clear_queue(CircularQueue* queue) {
    if (!queue) return -1;
    queue->head = queue->tail = 0;
    return 0;
}

int destroy_queue(CircularQueue* queue) {
    if (!queue) return -1;
    free(queue);
    queue = NULL;
    return 0;
}

test.c

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

int main() {
    CircularQueue* q = create_queue();
    enqueue(q, 10);
    enqueue(q, 20);
    enqueue(q, 30);
    clear_queue(q);
    enqueue(q, 40);
    enqueue(q, 50);
    enqueue(q, 60);
    enqueue(q, 70);

    while (!is_empty(q)) {
        printf("dequeue: %d\n", dequeue(q));
    }

    clear_queue(q);
    destroy_queue(q);
    return 0;
}

연결 리스트 기반 큐

linkqueue.h

typedef int QueueData;

typedef struct Node {
    QueueData value;
    struct Node* next;
} ListNode;

typedef struct {
    ListNode* front;
    ListNode* rear;
} LinkedQueue;

LinkedQueue* init_queue();
int push(LinkedQueue* queue, QueueData data);
QueueData pop(LinkedQueue* queue);
int is_queue_empty(LinkedQueue* queue);
int empty_queue(LinkedQueue* queue);
int release_queue(LinkedQueue* queue);

linkqueue.c

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

LinkedQueue* init_queue() {
    LinkedQueue* q = (LinkedQueue*)malloc(sizeof(LinkedQueue));
    if (!q) {
        fprintf(stderr, "메모리 할당 실패\n");
        return NULL;
    }
    q->front = (ListNode*)malloc(sizeof(ListNode));
    if (!q->front) {
        fprintf(stderr, "메모리 할당 실패\n");
        return NULL;
    }
    q->front->value = 0;
    q->front->next = NULL;
    q->rear = q->front;
    return q;
}

int push(LinkedQueue* queue, QueueData data) {
    ListNode* new_node = (ListNode*)malloc(sizeof(ListNode));
    if (!new_node) {
        fprintf(stderr, "메모리 할당 실패\n");
        return -1;
    }
    new_node->value = data;
    new_node->next = NULL;
    queue->rear->next = new_node;
    queue->rear = new_node;
    return 0;
}

QueueData pop(LinkedQueue* queue) {
    if (!queue || queue->front == queue->rear) {
        fprintf(stderr, "큐가 비어 있음\n");
        return -1;
    }
    ListNode* temp = queue->front->next;
    QueueData result = temp->value;
    if (temp->next == NULL) {
        queue->front->next = NULL;
        queue->rear = queue->front;
    } else {
        queue->front->next = temp->next;
    }
    free(temp);
    return result;
}

int is_queue_empty(LinkedQueue* queue) {
    if (!queue) return -1;
    return (queue->front == queue->rear) ? 1 : 0;
}

int empty_queue(LinkedQueue* queue) {
    if (!queue) return -1;
    ListNode* current = queue->front->next;
    while (current) {
        ListNode* next = current->next;
        printf("정리: %d\n", current->value);
        free(current);
        current = next;
    }
    queue->front->next = NULL;
    queue->rear = queue->front;
    return 0;
}

int release_queue(LinkedQueue* queue) {
    if (!queue) return -1;
    ListNode* current = queue->front;
    while (current) {
        ListNode* next = current->next;
        printf("해제: %d\n", current->value);
        free(current);
        current = next;
    }
    free(queue);
    queue = NULL;
    return 0;
}

test.c

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

int main() {
    LinkedQueue* q = init_queue();
    push(q, 10);
    push(q, 20);
    push(q, 30);
    push(q, 40);

    while (!is_queue_empty(q)) {
        printf("dequeue: %d\n", pop(q));
    }

    empty_queue(q);
    push(q, 40);
    while (!is_queue_empty(q)) {
        printf("dequeue: %d\n", pop(q));
    }

    release_queue(q);
    return 0;
}