1. ํ(queue)์ ๊ฐ๋
- ํ์ ์คํ์ ๊ณตํต์ ์ ๊ฐ์ฒด์ ๊ทธ ๊ฐ์ฒด๊ฐ ์ ์ฅ๋๋ ์์๋ฅผ ๊ธฐ์ตํ๋ ๋ฐฉ๋ฒ์ ๊ดํ ์ถ์ ์๋ฃํ์ด๋ผ๋ ๊ฒ
- ๊ฐ์ฅ ๋จผ์ ์ ๋ ฅ๋ ์๋ฃ๊ฐ ๊ฐ์ฅ ๋จผ์ ์ถ๋ ฅ๋๋ ๊ด๊ณ๋ฅผ ํํํ๋ค.
- FIFO(First In First Out, ์ ์ ์ ์ถ)
- FCFS(First Come First Servce, ์ ์ฐฉ์ ์๋ธ)
- ํ์ชฝ ๋์์๋ ์์์ ์ฝ์ ์ฐ์ฐ๋ง, ๋ค๋ฅธ ํ์ชฝ ๋์์๋ ์ญ์ ์ฐ์ฐ๋ง ๋ฐ์
- ๋๊ฐ์ ํ ํฌ์ธํฐ ๋ณ์(์ผ๋ฐ์ ์ผ๋ก front, rear๋ก ๋ช ๋ช )๋ฅผ ์ฌ์ฉํ๋ค.
- front๋ ํ์ ์ญ์ ๊ฐ ๋ฐ์ํ๋ ์ง์ ์ ๊ฐ๋ฆฌํจ๋ค.
- rear๋ ํ์ ์ฝ์ ์ด ๋ฐ์ํ๋ ์ง์ ์ ๊ฐ๋ฆฌํจ๋ค.
- ์ฝ์ ์ rear๋ฅผ ์ฆ๊ฐ์ํค๊ณ ์ญ์ ์ front๋ฅผ ๊ฐ์์ํจ๋ค.
2. ํ์ ์ถ์ ์๋ฃํ(ADT)
* Object(๊ฐ์ฒด)
0๊ฐ ์ด์์ ์์๋ฅผ ๊ฐ๋ ์ ํ ์์ ๋ฆฌ์คํธ
* Functions(์ฐ์ฐ)
queue∈Queue, item∈element, maxQueueSize∈positive interger์ธ ๋ชจ๋ queue, item, maxQueueSize์ ๋ํ์ฌ ๋ค์๊ณผ ๊ฐ์ ์ฐ์ฐ์ด ์ ์๋๋ค. queue๋ 0๊ฐ ์ด์์ ์์๋ฅผ ๊ฐ๋ ํ, item์ ํ์ ์ฝ์ ๋๋ ์์, maxQueueSize๋ ํ์ ์ต๋ ํฌ๊ธฐ๋ฅผ ์ ์ํ๋ ์ ์์ด๋ค.
โ Queue createQueue(maxQueueSize) ::= ํ์ ํฌ๊ธฐ๊ฐ maxSizeQueue์ธ ๋น ํ๋ฅผ ์์ฑํ๊ณ ๋ฐํํ๋ค;
โก Boolean isQueueFull(queue) ::=
if((queue์ elements ๊ฐ์) == maxQueueSize)
then { 'TRUE' ๋ฐํ; }
else { 'FALSE' ๋ฐํ; }
โข Queue addQueue(queue, item) ::=
if(isQueueFull(queue))
then { 'queueFull' ์ถ๋ ฅ; }
else { ํ์ rear์์ item์ ์ฝ์ ํ๊ณ ํ๋ฅผ ๋ฐํํ๋ค; }
โฃ Boolean isQueueEmpty(queue) ::=
if(rear == front)
then { 'TRUE' ๋ฐํ; }
else { 'FALSE' ๋ฐํ; }
โค Element deleteQueue(queue) ::=
if(isQueueEmpty(queue))
then { 'queueEmpty' ๋ฐํ; }
else { ํ์ front์ ์๋ element๋ฅผ ์ญ์ ํ๊ณ ๋ฐํํ๋ค; }
ํ์ ์ถ์ ์๋ฃํ์์ ์ ์๋ ์ฐ์ฐ์ ์์คํ ๊ฐ๋ฐ์์ ๋ฐ๋ผ ๋ค๋ฅด๊ฒ ์ ์๋๊ณ ๊ตฌํ๋ ์ ์๊ณ , ์ปดํ์ผ๋ฌ ์ค๊ณ์์ ๋ฐ๋ผ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์ ๋ค๋ฅด๊ฒ ์ ๊ณต๋ ์ ์๋ค.
3. ํ ์ฐ์ฐ ์ํ
โ createQueue(4);
โก addQueue(queue, 'A');
โข addQueue(queue, 'B');
โฃ addQueue(queue, 'C');
โค deleteQueue(queue);
โฅ deleteQueue(queue);
โฆ deleteQueue(queue);
โง addQueue(queue, 'D');
โฆ๊ณผ ๊ฐ์ด rear ํฌ์ธํฐ์ front ํฌ์ธํฐ๊ฐ ๊ฐ์ ์ฅ์๋ฅผ ๊ฐ๋ฆฌํค๋ฉด(=๊ฐ์ ๊ฐ์ด๋ฉด) ํ๋ empty ์ํ์ด๋ค.
4. ๋ฐฐ์ด์ ์ด์ฉํ ํ์ ๊ตฌํ
๋ค์์ C์ธ์ด๋ก ๊ตฌํํ intํ ํ์ด๋ค.
4-1. ํ์ ์์ฑ
1
2
3
4
5
|
#define QUEUE_SIZE 5
typedef int element;
element queue[QUEUE_SIZE];
int front = -1;
int rear = -1;
|
cs |
1๋ผ์ธ: ํ์ ์ฌ์ด์ฆ๋ฅผ 5๋ก ์ ์ํ๋ค.
2๋ผ์ธ: ํ์ element๋ฅผ intํ์ผ๋ก ์ ์ํ๋ค.
3๋ผ์ธ: element๋ฅผ ์ ์ฅํ ์ ์๋ ํ๋ฅผ QUEUE_SIZE๋งํผ ํ ๋น๋ฐ๋๋ค.
4,5๋ผ์ธ: front์ rear๋ฅผ -1๋ก ์ด๊ธฐํํ๋ค.
4-2. ํ์ ์ฝ์
๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ์ฝ์ ์ฐ์ฐ์ด ๋ฐ์ํ๋ฉด rear ๋ณ์๋ง ์ค๋ฅธ์ชฝ์ผ๋ก ์ด๋(์ฆ๊ฐ)ํ๋ค.
1
2
3
4
5
6
7
8
9
|
void addQueue(int *rear, element item) {
if(*rear == QUEUE_SIZE-1) {
printf("Queue is Full\n");
return;
}
queue[++(*rear)] = item;
return;
}
|
cs |
1๋ผ์ธ: rear ๋ณ์์ ์ฃผ์๊ฐ๊ณผ ์ฝ์ ํ ๋ฐ์ดํฐ๋ฅผ ๋งค๊ฐ๋ณ์๋ก ์ ๋ฌํ๋ค.
2๋ผ์ธ: if(*rear == QUEUE_SIZE-1)
ํธ์์ *rear ๋ณ์๋ฅผ ํตํด ํ๊ฐ ๋ง์ ์ํ(full)์ธ์ง ๊ฒ์ฌํ๋ค. ๋ง์ ์ํ์ด๋ฉด ๋ฉ์์ง๋ฅผ ์ถ๋ ฅํ๊ณ ์ข ๋ฃํ๋ค.
7๋ผ์ธ: queue[++(*rear)] = item;
ํ๊ฐ ๋ง์ ์ํ๊ฐ ์๋๋ฉด *rear๋ฅผ 1 ์ฆ๊ฐ์ํค๊ณ queue์ ํด๋น ์ธ๋ฑ์ค์ item์ ์ ์ฅํ๋ค.(์์ ์ค์)
4-3. ํ์ ์ญ์
์ญ์ ์ฐ์ฐ์ด ๋ฐ์ํ๋ฉด front ๋ณ์๋ง ์ค๋ฅธ์ชฝ์ผ๋ก ์ด๋(์ฆ๊ฐ)ํ๋ค.
1
2
3
4
5
6
7
8
|
element deleteQueue(int *front, int rear) {
if(*front == rear) {
print("Queue is Empty\n");
return;
}
return (queue[++(*front)]);
}
|
cs |
1๋ผ์ธ: front ๋ณ์์ ์ฃผ์๊ฐ๊ณผ rear ๋ณ์๋ฅผ ๋งค๊ฐ๋ณ์๋ก ์ ๋ฌํ๋ค.
2๋ผ์ธ: if(*front == rear)
front์ rear๋ฅผ ๋น๊ตํด ํ๊ฐ ๋น ์ํ(empty)์ธ์ง ๊ฒ์ฌํ๋ค. front์ rear๊ฐ ๊ฐ์ผ๋ฉด ๋น ์ํ์ด๋ค. ๋น ์ํ์ด๋ฉด ๋ฉ์์ง๋ฅผ ์ถ๋ ฅํ๊ณ ์ข ๋ฃํ๋ค.
7๋ผ์ธ: return (queue[++(*front)]);
ํ๊ฐ ๋น ์ํ๊ฐ ์๋๋ฉด *front๋ฅผ 1 ์ฆ๊ฐ์ํค๊ณ queue์ ํด๋น ์ธ๋ฑ์ค์ ์๋ element๋ฅผ ๋ฐํํ๋ค.(์์ ์ค์)
5. ํ์ ์์ฉ ๋ถ์ผ
- ํ๋ ๋ํ์ ์ผ๋ก CPU์ ๊ด๋ฆฌ ๋ฐฉ๋ฒ์ ํ์ฉ๋๋ค.
- FCFS(First Com First Served) ์ค์ผ์ค๋ง ๊ธฐ๋ฒ : FIFO(First In First Out) ์ค์ผ์ค๋ง์ด๋ผ๊ณ ๋ ํ๋ค. ์์ (ํ๋ก๊ทธ๋จ)์ด ์ค๋น ํ์ ๋์ฐฉํ ์์๋๋ก CPU๋ฅผ ํ ๋น๋ฐ๋ ๊ธฐ๋ฒ์ด๋ค.
- RR(Round Robin) ์ค์ผ์ค๋ง ๊ธฐ๋ฒ : ๋ํํ ์์คํ ์ ์ฌ์ฉ๋๋ ์ค์ผ์ค๋ง ๋ฐฉ์์ด๋ค. ๋์ฐฉํ ์์๋๋ก CPU๊ฐ ํ ๋น๋์ง๋ง CPU์ ์๊ฐ ํ ๋น๋ ๋๋ ์๊ฐ ๊ฐ๊ฒฉ์ ์ํด ์ ํ์ ๋ฐ๋๋ค. ์ผ์ ํ ํฌ๊ธฐ์ ์๊ฐ ํ ๋น๋์ ๋ชจ๋ ์์ ์ ์ฃผ๊ณ ๊ทธ ์๊ฐ ๋์ ์์ ์ด ์๋ฃ๋์ง ๋ชปํ๋ฉด ์ค๋น ํ์ ๋งจ ๋ค์ ๋ค์ ๋ฐฐ์นํ๋ค.
6. ์ํ ํ(Circular Queue)
๋ฐฐ์ด๋ก ๊ตฌํ๋ ์ฌ์ด์ฆ 5์ง๋ฆฌ ํ์ด๋ฉฐ 5๊ฐ์ element๊ฐ ๋ชจ๋ ์ฑ์์ง ๊ฒฝ์ฐ์ด๋ค. ์ฆ ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ 100% ์ฌ์ฉํ๋ค.
100๊ณผ 200์ด ์ญ์ ๋์ด ํ์ element๊ฐ ๋ชจ๋ ์ฑ์์ง์ง ์์์ง๋ง ์ถ๊ฐ element ์ฝ์ ์ด ๋ถ๊ฐ๋ฅํ๋ค. ๋ฐฐ์ด๋ก ๊ตฌํ๋ ํ๋ ์ ์๋ ๋ฐฐ์ด์ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ๋ณํ์ํฌ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. queue[4]๊ฐ ๋ง์ง๋ง ๊ณต๊ฐ์ด๊ณ rear๊ฐ ๋ ์ด์ ์์ผ๋ก ์ฆ๊ฐํ ์ ์๋ค. element๊ฐ ์ฝ์ ๋ ๋๋ง๋ค rear๋ 1์ฉ ์ฆ๊ฐ๋๋ค. ํ์ ํฌ๊ธฐ๊ฐ n์ด๋ฉด n-1์ ์์น๊น์ง ์ค๊ณ ๋์ด์ ์ ์ฅํ ์ ์๋ ์ํ๊ฐ ๋๋ค. ํ์ง๋ง ์ ์์์ฒ๋ผ ํ์ ์ ์ฅ๋ element๋ n๊ฐ๊ฐ ์๋ ์ ์๋ค.
์์ ์ ์ํ ํ์ ์ถ์ ์๋ฃํ์์๋ 'ํ์ element ๊ฐ์ == maxQueueSize'๋ฅผ ํ์ ๋ง์ ์ํ๋ก ์ ์ํ๊ณ ์๋ค. ์ฆ rear๊ฐ์ผ๋ก ํ์ ๋ง์ ์ํ๋ฅผ ๊ฒฐ์ ํ์ง ์๋๋ค.(๋ฐฐ์ด์ ์ด์ฉํด ๊ตฌํํ ํ์์๋ ํธ์์ rear๊ฐ์ผ๋ก ํ๋จํจ) ์ด ๋๋ฌธ์ front๋ถํฐ ์ด์ ์ ๋น ๊ณต๊ฐ์ ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น๊ฐ ๋ฐ์ํ๋ค. ์ด๋ ํ๋ฅผ ๋ฐฐ์ด๋ก ๊ตฌํํ๊ธฐ ๋๋ฌธ์ ๋ฐ์ํ๋ ๋ฌธ์ ์ ์ด๋ค.
์ด๋ฌํ ๋ฌธ์ ์ ์ ํด๊ฒฐํ๊ธฐ ์ํด ์ํ ํ๊ฐ ์ ์๋์๋ค.
์ํ ํ๋ ํ์ดํ์ ์ ๊ตฌ์ ์ถ๊ตฌ๋ฅผ ์ฐ๊ฒฐ์ํจ ํํ์ด๋ค.
์์ ๋ณธ ํ์ ๋์ผํ ๋ฐ์ดํฐ๊ฐ ์ ์ฅ๋ผ์๋ ์ํ ํ์ด๋ค. ๋ ๋ค rear๊ฐ์ด n-1์ธ ์ํฉ์ด๋ค. '600'์ ์ฝ์ ํ๋ ค ์๋ํ๋ฉด ๋ฐฐ์ด๋ก ๊ตฌํ๋ ์ผ๋ฐ ํ์๋ ๋ ์ด์ ์ฝ์ ์ด ๋ถ๊ฐ๋ฅํ๋ค. ํ์ง๋ง ์ํ ํ์์๋ ์ฝ์ ์ด ๊ฐ๋ฅํ๋ค.
์ํ ํ๋ ๊ณต๊ฐ์ ์ฌ์ฌ์ฉํ์ฌ ๋ฉ๋ชจ๋ฆฌ ํ์ฉ๋๋ฅผ ๋์ผ ์ ์๋ค. ์ด๋ฅผ ๊ตฌํํ๋ ค๋ฉด near์ ์์น๊ฐ n-1์ผ ๋ ์ฝ์ ์ด ๋ฐ์ํ๋ฉด rear๋ฅผ 0์ผ๋ก ๋ณ๊ฒฝํด์ผ ํ๋ค.
๋๋จธ์ง๋ฅผ ๊ณ์ฐํ๋ mod(modulus) ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ์ฌ rear๊ฐ์ ๊ด๋ฆฌํ๋ค.
์ํ ํ์ element๋ฅผ ์ฝ์ ํ ๋ 'rear ← (rear + 1) mod n' ํน์ 'front ← (front + 1) mod n' ์ฐ์ฐ์์ ์ด์ฉํ๋ค.
์:
โ ๋ฐฐ์ด๋ก ๊ตฌํ๋ ์ฌ์ด์ฆ 5 ์ํ ํ์ rear๊ฐ 3์ธ ์ํ์์ ์ฝ์ ์ด ๋ฐ์ํ๋ค.
โก '(3+1) mod 5'์ ๊ฒฐ๊ณผ์ธ 4๋ฅผ rear ๊ฐ์ผ๋ก ๊ฐ๋๋ค. → rear = n-1
โข ๊ฐ์ ์ ์ฅํ๋ค.
โฃ ๋ค์ ์ฝ์ ์ด ๋ฐ์ํ๋ค.
โค '(4+1) mod 5'์ ๊ฒฐ๊ณผ์ธ 0์ rear ๊ฐ์ผ๋ก ๊ฐ๋๋ค. → rear = 0
7. ์ฐ์ต๋ฌธ์
1. ์๋ฃ๊ตฌ์กฐ์ ์ ํ ์ค ์ ํ ๊ตฌ์กฐ์ ํด๋นํ๋ ๊ฒ์ ๋ฌด์์ธ๊ฐ?
โ ํ
โก ๊ทธ๋ํ
โข ํธ๋ฆฌ
โฃ ํข
2. ํ์์ element๋ฅผ ์ฝ์ ํ ๊ฒฝ์ฐ์ ์ค๋ช ์ผ๋ก ๋ง๋ ๊ฒ์?
โ rear์ ์์น๋ฅผ ๊ฐ์์ํจ ํ element๋ฅผ ์ฝ์
โก front์ ์์น๋ฅผ ์ฆ๊ฐ์ํจ ํ element๋ฅผ ์ฝ์
โข rear์ ์์น๋ฅผ ์ฆ๊ฐ์ํจ ํ element๋ฅผ ์ฝ์
โฃ front์ ์์น๋ฅผ ๊ฐ์์ํจ ํ element๋ฅผ ์ฝ์
3. ๋ค์์ ํ์ ์์๋ฅผ ์ฝ์ ํ๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. (๊ฐ)์ (๋)์ ์๋ง์ ๊ฒ์?
โ (๊ฐ) *rear == QUEUE_SIZE, (๋) (*rear)++
โก (๊ฐ) *rear == QUEUE_SIZE, (๋) ++(*rear)
โข (๊ฐ) *rear == QUEUE_SIZE-1, (๋) ++(*rear)
โฃ (๊ฐ) *rear == QUEUE_SIZE-1, (๋) (*rear)++
4. ํ์ดํ์ ์ ๊ตฌ์ ์ถ๊ตฌ๋ฅผ ์ฐ๊ฒฐ์ํจ ํํ์ ํ๋ก ๊ธฐ์ต์ฅ์์ ๋ญ๋น๋ฅผ ์ค์ด๊ธฐ ์ํ ์๋ฃ๊ตฌ์กฐ๋ ๋ฌด์์ธ๊ฐ?
โ ์ฐ๊ฒฐ ํ
โก ์ด์ค ํ
โข ์ํ ํ
โฃ ๋ฐ ํ
5. ๋ค์ ํ์ ๋ํ ์ค๋ช ์ผ๋ก ํ๋ฆฐ ๊ฒ์ ๋ชจ๋ ๊ณ ๋ฅด์์ค.
โ ์ํ ํ๋ ์ ๊ตฌ(rear ๋ณ์)์ ์ถ๊ตฌ(front ๋ณ์)๋ฅผ ์ฐ๊ฒฐํ์ฌ ๋ฐ์ดํฐ ๊ณต๊ฐ์ ์ฐ์์ ์ผ๋ก ์ฌ์ฉํ๊ธฐ ์ํด ์ ์๋์๋ค.
โก ํ๋ ์๋ก ๋ค๋ฅธ ๋ถ๋ถ์์ ์ฝ์ ๊ณผ ์ญ์ ๊ฐ ๋ฐ์ํ๋ FIFO ํน์ฑ์ ๊ฐ๋ ์์ ๋ฆฌ์คํธ์ด๋ค.
โข ํ๊ฐ ๊ฐ๋ ์ฐฌ ์ํ๋ ์ฝ์ ๋๋ ๋ถ๋ถ์ rear ๋ณ์์ ์ญ์ ๋๋ ๋ถ๋ถ์ front ๋ณ์๋ฅผ ์ด์ฉํ์ฌ ์ ์ ์๋ค.
โฃ ์ฝ์ ๋๋ ๋ถ๋ถ์ rear ๋ณ์๊ฐ ๋ง์ง๋ง์ ๊ฐ๋ฆฌํค๋ฉด ํ์ ํฌํจ๋ ์์์ ๊ฐฏ์๋ ํ์ ํฌ๊ธฐ์ ๊ฐ๊ณ ํ๊ฐ ๊ฐ๋ ์ฐฌ ์ํ์ด๋ค.
6. ํ์ ์ด์ฉ๊ณผ ์ ์ฌํ๊ฒ ์ด์๋๋ ๊ฒ์ด ์๋ ๊ฒ์ ๋ฌด์์ธ๊ฐ?
โ ๋ฌธ์ ์ถ๋ ฅ์ ์ํด ํ๋ฆฐํฐ๊ธฐ๋ฅผ ์ด์ฉํ ๋ ์ฌ๋ฌ ๊ฐ์ ๋ฌธ์๋ฅผ ์ถ๋ ฅํด๋ ๋จผ์ ์ธ์๋ฒํผ์ ๋๋ฅธ ๋ฌธ์๋ถํฐ ์ฐจ๋ก๋ก ์ถ๋ ฅ๋๋ค.
โก ์ํ์์ ๋ฒํธํ๋ฅผ ๋ฝ๊ณ ์ฐฝ๊ตฌ์ ๊ฐ๊ธฐ๋ฅผ ๊ธฐ๋ค๋ฆฐ๋ค.
โข ํ์ ์น๊ฐ์ฅ์ ์ค์ ์์ ํ์๋ฅผ ๊ธฐ๋ค๋ฆฐ๋ค.
โฃ ์น๋ธ๋ผ์ฐ์ ์์ ๋ฐฉ๊ธ ์ ๋ฐฉ๋ฌธํ๋ ์ฌ์ดํธ ๊ธฐ๋ก ์ ์ฅ ํ '์ด์ ํ์ด์ง๋ก ๋์๊ฐ๊ธฐ'๋ฅผ ํด๋ฆญํ๋ค.
7. ๋ค์์ ํ์ ๋ํ ์ฐ์ฐ์ด๋ค. โง ์ฐ์ฐ ์ํ ํ ํ์ ๋ชจ์ต์ ๋ฌด์์ธ๊ฐ?
์ ๋ต โผ
1 : โ
2 : โข
3 : โข
4 : โข
5 : โข,โฃ
6 : โฃ
7 : โฃ
'Computer Science' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๊ณ ๋ฆฌ์ฆ] ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ๋ ๊ณผ ๊ธฐ๋ณธ ์๋ฃ๊ตฌ์กฐ (0) | 2020.03.10 |
---|---|
[์๋ฃ๊ตฌ์กฐ] ๋จ์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ(singly linked list) - ์ ๋ฆฌ ๋ฐ ์ฐ์ต๋ฌธ์ (0) | 2019.11.20 |
[์๋ฃ๊ตฌ์กฐ] ์คํ - ์ ๋ฆฌ ๋ฐ ์ฐ์ต๋ฌธ์ (0) | 2019.11.19 |
[์๋ฃ๊ตฌ์กฐ] ๋ฐฐ์ด - ์ ๋ฆฌ ๋ฐ ์ฐ์ต๋ฌธ์ (2) | 2019.11.19 |
[์๋ฃ๊ตฌ์กฐ] ์๋ฃ๊ตฌ์กฐ๋ ๋ฌด์์ธ๊ฐ? - ์ ๋ฆฌ ๋ฐ ์ฐ์ต๋ฌธ์ (0) | 2019.11.18 |
๋๊ธ