ํ๋?
ํ๋ ์ปดํจํฐ์ ๊ธฐ๋ณธ์ ์ธ ์๋ฃ๊ตฌ์กฐ์ ํ๊ฐ์ง๋ก, ๋จผ์ ์ง์ด ๋ฃ์ ๋ฐ์ดํฐ๊ฐ ๋จผ์ ๋์ค๋ FIFO(First in First out) ๊ตฌ์กฐ๋ก ์ ์ฅํ๋ ํ์์ ๋งํ๋ค. ๋์ค์ ์ง์ด ๋ฃ์ ๋ฐ์ดํฐ๊ฐ ๋จผ์ ๋์ค๋ ์คํ๊ณผ๋ ๋ฐ๋๋๋ ๊ฐ๋ ์ด๋ค.
์คํ์ ์๋ ๋ถ๋ถ์ด ๋งํ๊ณ ์ ๋ถ๋ถ์ด ๋ซ๋ฆฐ ํต๊ณผ ๊ฐ์๋ค๋ฉด, ํ๋ ์ ์ชฝ์ด ๋ซ๋ฆฐ ํต๊ณผ ๊ฐ๋ค. ์คํ์ด ๊ฐ์ฅ ์๋ถ๋ถ์์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ๊ณ ๊บผ๋๋ค๋ฉด, ํ๋ front์์ dequeue ์ฐ์ฐ์ด ์งํ๋๊ณ , rear ๋ถ๋ถ์์ enqueue ์ฐ์ฐ์ด ์งํ๋๋ค.
C์ธ์ด ๊ตฌํ
ํ๋ ๋ฐฐ์ด ํน์ ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ก ๊ตฌํํ ์ ์๋ค. ๋ฐฐ์ด๋ก ๊ตฌํํ ์์๋ ์ฌ๋ฌ๊ฐ์ง ๋ฌธ์ ์ ์ด ๋ฐ์ํ ์ ์๋ค. ์ฌ๊ธฐ์๋ ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ฅผ ์ด์ฉํด ํ๋ฅผ ๊ตฌํํด๋ณด๋๋ก ํ๋ค.
1. ๋ ธ๋ ์ ์ ๋ฐ ํ ์ด๊ธฐํ
#include <stdio.h>
#include <stdlib.h>
typedef struct Node
{
int data;
struct Node *next;
}Node;
typedef struct Queue
{
Node *front;
Node *rear;
int count; // ํ ์์ ๋
ธ๋ ๊ฐ์
}Queue;
void initQueue(Queue *queue)
{
queue->front = queue->rear = NULL;
queue->count = 0; // ํ ์์ ๋
ธ๋ ๊ฐ์๋ฅผ 0์ผ๋ก ์ค์
}
์ถ์ฒ: https://code-lab1.tistory.com/6?category=1213002 [์ฝ๋ ์ฐ๊ตฌ์:ํฐ์คํ ๋ฆฌ]
๊ฐ์ฅ ๋จผ์ ๋ ธ๋๋ฅผ ์ ์ํ๊ณ , Queue ๊ตฌ์กฐ์ฒด๋ฅผ ์ ์ํ๋ค. ํ๋ฅผ ์ด๊ธฐํํ๋ initQueue() ํจ์๋ฅผ ์ด์ฉํด front์ rear๋ฅผ Null ๋ก ์ด๊ธฐํํ๊ณ , ํ ์์ ๋ ธ๋ ๊ฐ์๋ฅผ ๋ํ๋ด๋ count๋ฅผ 0์ผ๋ก ์ด๊ธฐํํ๋ค.
2. isEmpty() ํจ์
ํ์์ ๋ฐ์ดํฐ๋ฅผ ๋ฝ์๋ผ ๋ ํ๊ฐ ๋น์ด์๋ค๋ฉด ์ค๋ฅ๊ฐ ๋ฐ์ํ ์ ์๋ค.
๋ฐ๋ผ์ ํ๊ฐ ๋น์ด ์๋์ง ํ์ธํ๋ ํจ์์ธ isEmpty()๊ฐ ํ์ํ๋ค.
int isEmpty(Queue *queue){
return queue->count == 0; // ํ์์ ๋
ธ๋ ๊ฐ์๊ฐ 0์ด๋ฉด ๋น ์ํ
}
์ถ์ฒ: https://code-lab1.tistory.com/6?category=1213002 [์ฝ๋ ์ฐ๊ตฌ์:ํฐ์คํ ๋ฆฌ]
ํ๊ฐ ๋น์ด์๋์ง ํ์ธํ๋ ํจ์๋ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ ์ฌ์ฉํ ์ ์๋ค.
queue->front == NULL && queue->rear==NULL
์ฒซ๋ฒ์งธ ๊ฒฝ์ฐ๋ ํ์ front์ rear๊ฐ null์ผ ๊ฒฝ์ฐ์ด๋ค. ์ด๋ฐ ๊ฒฝ์ฐ๋ ๋น์ด์์ ๋๋ฟ์ด๊ธฐ ๋๋ฌธ์ด๋ค.
๋๋ฒ์งธ ๊ฒฝ์ฐ๋ ํ์์ ๋ ธ๋ ๊ฐ์๊ฐ 0์ด๋ผ๋ฉด ํ๊ฐ ๋น ์ํ๋ก ์ทจ๊ธํ๋ค.
3. ํ์ ์ฝ์ (enqueue)
ํ์ ๋ฐ์ดํฐ ์ฝ์ ์ rear ๋ถ๋ถ, ์ฆ ํ์ ๋งจ ๋ค์์ ๋ฐ์ํ๋ค. ๊ฐ์ฅ ๋จผ์ ์๋ก์ด ๋ ธ๋๋ฅผ ๋ง๋ค์ด data๋ฅผ ํ ๋นํ๊ณ , ์ดํ ํ์ ์ง์ด ๋ฃ๋๋ค.
void enqueue(Queue *queue, int data)
{
Node *newNode = (Node *)malloc(sizeof(Node)); // newNode ์์ฑ
newNode->data = data;
newNode->next = NULL;
if (isEmpty(queue)) // ํ๊ฐ ๋น์ด์์ ๋
{
queue->front = newNode;
}
else // ๋น์ด์์ง ์์ ๋
{
queue->rear->next = newNode; //๋งจ ๋ค์ ๋ค์์ newNode๋ก ์ค์
}
queue->rear = newNode; //๋งจ ๋ค๋ฅผ newNode๋ก ์ค์
queue->count++; //ํ์์ ๋
ธ๋ ๊ฐ์๋ฅผ 1 ์ฆ๊ฐ
}
์ถ์ฒ: https://code-lab1.tistory.com/6?category=1213002 [์ฝ๋ ์ฐ๊ตฌ์:ํฐ์คํ ๋ฆฌ]
์ฝ๋๋ฅผ ๋ณด๊ณ ์ดํด๊ฐ ๊ฐ์ง ์๋๋ค๋ฉด ๋ค์ ๊ทธ๋ฆผ์ ๋ณด์.

ํ๊ฐ ๋น์ด์์ ๋ enqueue
ํ๊ฐ ๋น์ด์์ ๋ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ ํ๋ฉด, front์ rear๊ฐ ๋์ผํ๊ฒ newNode๋ฅผ ๊ฐ๋ฆฌํค๊ฒ ๋๋ค.

ํ๊ฐ ๋น์ด์์ง ์์ ๋ enqueue
ํ๊ฐ ๋น์ด์์ง ์์ ๋ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ ํ๋ฉด front๋ ๊ฐ์ฅ ์์ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๊ณ rear๋ ๊ฐ์ฅ ๋ค์ ๋ ธ๋ ์ฆ, ๋ฐฉ๊ธ ์ฝ์ ํ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๊ฒ ๋๋ค. ์ด๋ ๋ค์๊ณผ ๊ฐ์ ๊ณผ์ ์ ๊ฑฐ์ณ์ ์ด๋ฃจ์ด์ง๋ค.
1. newNode ์์ฑ
2. rear์ next ๊ฐ newNode๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ์ค์
3. rear๊ฐ newNode๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ์ค์
next ํฌ์ธํฐ๊ฐ enqueue ๋๋ ๋ฐฉํฅ๊ณผ ๋ฐ๋๋ก ์ค์ ๋๋๊ฒ ์ด์ํ ์๋ ์์ผ๋, ์ด๋ dequeue ์ฐ์ฐ์ ์ํด์๋ค. dequeue ์ฐ์ฐ์์ ์์ธํ ๋ณด๋๋ก ํ์.
4. ํ์ ๋ฐ์ดํฐ ๋ฐํ(dequeue)
int dequeue(Queue *queue)
{
int data;
Node *ptr;
if (isEmpty(queue)) //ํ๊ฐ ๋น์์ ๋
{
printf("Error : Queue is empty!\n");
return 0;
}
ptr = queue->front; //๋งจ ์์ ๋
ธ๋ ptr ์ค์
data = ptr->data; // return ํ ๋ฐ์ดํฐ
queue->front = ptr->next; //๋งจ ์์ ptr์ ๋ค์ ๋
ธ๋๋ก ์ค์
free(ptr); // ptr ํด์
queue->count--; //ํ์ ๋
ธ๋ ๊ฐ์๋ฅผ 1 ๊ฐ์
return data;
}
์ถ์ฒ: https://code-lab1.tistory.com/6?category=1213002 [์ฝ๋ ์ฐ๊ตฌ์:ํฐ์คํ ๋ฆฌ]
ํ์์ ๋ฐ์ดํฐ ๋ฐํ์ ํ์ ๋งจ ์ front ์์ ๋ฐ์ํ๋ค.
ํ๊ฐ ๋น์ด ์์ ๊ฒฝ์ฐ์๋ ๋ฐ์ดํฐ ๋ฐํ์ ํ ์ ์์ผ๋ฏ๋ก ์ค๋ฅ ๋ฉ์์ง๋ฅผ ์ถ๋ ฅํ๋ค. ํ๊ฐ ๋น์ด ์์ง ์๋ค๋ฉด ๋งจ ์์ ๋ ธ๋์ ๋ฐ์ดํฐ๋ฅผ ๋ฐํํ๊ณ , ํด๋น ๋ ธ๋๋ฅผ free ์์ผ์ค๋ค. ์ดํ ํ์ ๋ ธ๋ ๊ฐ์๋ฅผ 1 ๊ฐ์ ์ํจ๋ค.
ํ๊ฐ ๋น์ด์์ง ์์ ๊ฒฝ์ฐ ๋ฐ์ดํฐ๋ฅผ ๋ฐํํ๋ ๊ณผ์ ์ ๊ทธ๋ฆผ์ผ๋ก ์์ธํ ์์๋ณด์.

๊ฐ์ฅ ๋จผ์ ptr์ด ํ์ front๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ํ๋ค. ์ด ๋ ๋ฐํํ ๋ฐ์ดํฐ๋ฅผ ๋ฐ๋ก ์ ์ฅํ๋ค. (์ฌ๊ธฐ์๋ ๋ก์ปฌ ๋ณ์ int data)

์ดํ front ๊ฐ ptr->next๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ํ๋ค. ์ด๋ฅผ ์ํด์ enqueue ๊ณผ์ ์์ next ํฌ์ธํฐ๋ฅผ ์ญ๋ฐฉํฅ์ผ๋ก ์ค์ ํ ๊ฒ์ด๋ค.

์ดํ ptr์ free(๋ฉ๋ชจ๋ฆฌ ํด์ )์์ผ์ฃผ๊ณ , ํ์ ๋ ธ๋ ๊ฐ์๋ฅผ 1๊ฐ์์ํจ๋ค. ๋ง์ง๋ง์ผ๋ก ๋ฐ๋ก ์ ์ฅํ data๋ฅผ ๋ฐํํ๋ฉด dequeue ๊ณผ์ ์ด ์๋ฃ๋๋ค.
์ ์ฒด ์ฝ๋
#include <stdio.h>
#include <stdlib.h>
typedef struct Node
{
int data;
struct Node *next;
}Node;
typedef struct Queue
{
Node *front;
Node *rear;
int count; // ํ ์์ ๋
ธ๋ ๊ฐ์
}Queue;
void initQueue(Queue *queue)
{
queue->front = queue->rear = NULL;
queue->count = 0; // ํ ์์ ๋
ธ๋ ๊ฐ์๋ฅผ 0์ผ๋ก ์ค์
}
int isEmpty(Queue *queue)
{
return queue->count == 0; // ํ์์ ๋
ธ๋ ๊ฐ์๊ฐ 0์ด๋ฉด ๋น ์ํ
}
void enqueue(Queue *queue, int data)
{
Node *newNode = (Node *)malloc(sizeof(Node)); // newNode ์์ฑ
newNode->data = data;
newNode->next = NULL;
if (isEmpty(queue)) // ํ๊ฐ ๋น์ด์์ ๋
{
queue->front = newNode;
}
else // ๋น์ด์์ง ์์ ๋
{
queue->rear->next = newNode; //๋งจ ๋ค์ ๋ค์์ newNode๋ก ์ค์
}
queue->rear = newNode; //๋งจ ๋ค๋ฅผ newNode๋ก ์ค์
queue->count++; //ํ์์ ๋
ธ๋ ๊ฐ์๋ฅผ 1 ์ฆ๊ฐ
}
int dequeue(Queue *queue)
{
int data;
Node *ptr;
if (isEmpty(queue)) //ํ๊ฐ ๋น์์ ๋
{
printf("Error : Queue is empty!\n");
return 0;
}
ptr = queue->front; //๋งจ ์์ ๋
ธ๋ ptr ์ค์
data = ptr->data; // return ํ ๋ฐ์ดํฐ
queue->front = ptr->next; //๋งจ ์์ ptr์ ๋ค์ ๋
ธ๋๋ก ์ค์
free(ptr); // ptr ํด์
queue->count--; //ํ์ ๋
ธ๋ ๊ฐ์๋ฅผ 1 ๊ฐ์
return data;
}
int main(void)
{
int i;
Queue queue;
initQueue(&queue);//ํ ์ด๊ธฐํ
for (i = 1; i <= 10; i++)
{
enqueue(&queue, i);
}
while (!isEmpty(&queue)) // ํ๊ฐ ๋น ๋๊น์ง
{
printf("%d ", dequeue(&queue)); //ํ์์ ๊บผ๋ด์จ ๊ฐ ์ถ๋ ฅ
}
printf("\n");
return 0;
}
์ถ์ฒ: https://code-lab1.tistory.com/6?category=1213002 [์ฝ๋ ์ฐ๊ตฌ์:ํฐ์คํ ๋ฆฌ]