๋๊ธฐํ๋ ฌ์ด๋ผ๋ ์๋ฏธ๋ก, ๊ฐ์ฅ ๋จผ์ ๋ค์ด์จ ๋ฐ์ดํฐ๊ฐ ๋๊ฐ๋๊น์ง ๋ค์ ๋ฐ์ดํฐ๋ ๋๊ฐ ์ ์๋ ์๋ฃ๊ตฌ์กฐ์ด๋ค.
์ฆ, ๊ฐ์ฅ ๋์ค์ ๋ค์ด์จ ๋ฐ์ดํฐ๊ฐ ๋๊ฐ๊ธฐ ์ํด์๋ ์ด์ ์ ๋ฐ์ดํฐ๋ค์ด ๋ชจ๋ ๋น ์ ธ๋๊ฐ๊ธฐ ์ ๊น์ง๋ ๋๊ฐ ์ ์๋ค.
๋ฐ๋ผ์, Stack๊ณผ๋ ๋ฐ๋๋๋ ๊ฐ๋ ์ผ๋ก, ๋จผ์ ๋ค์ด์จ ๋ฐ์ดํฐ๊ฐ ๋จผ์ ๋์ค๊ณ (FIFO), ๋์ค์ ๋ค์ด์จ ๋ฐ์ดํฐ๋ ๋์ค์ ๋์ค๊ฒ ๋๋ค(LILO).
์ด ๋, Queue์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ๋ ๊ฒ์ enqueue
, ๊บผ๋ด๋ ๊ฒ์ dequeue
๋ผ๊ณ ํ๋ค.
Queue์ ํน์ง์ ์ ๋ฆฌํ์๋ฉด, ์๋์ ๊ฐ๋ค.
FIFO (First In First Out) = ์ ์ ์ ์ถ
๋ฐ์ดํฐ๊ฐ ์๋ฌด๋ฆฌ ๋ง์๋ ํ๋์ฉ ๋ฃ๊ณ ๋บ ์ ์๋ค. (ํ๊บผ๋ฒ์ ์ฌ๋ฌ๊ฐ X)
๋ ๊ฐ์ ์ ์ถ๋ ฅ ๋ฐฉํฅ(์ ๋ ฅ ๋ฐ๋ก, ์ถ๋ ฅ ๋ฐ๋ก)
class Queue {
constructor() {
this.storage = {};
this.front = 0;
this.rear = 0;
}
// ์ถ๊ฐ๋ ๋ -> rear์ ๊ฐ์ด ์ปค์ง๊ณ
// ์ญ์ ๋ ๋ -> front ๋ณ๊ฒฝ
size() {
return this.rear-this.front;
}
// queue์ element(๋ฐ์ดํฐ)์ถ๊ฐ
// key : ์๋กญ๊ฒ ์ถ๊ฐ๋ element์ index๋ฅผ ๋ํ๋ด๋ this.rear
// value : element
// key์ value๋ฅผ storage์ ํ ๋นํ๊ณ , this.rear์ ๋ค์ ์ธ๋ฑ์ค๋ฅผ ๊ฐ๋ฆฌํค๊ฒ ํ์ฌ ์๋ก์ด element์ ๋๋น
enqueue(element) {
this.storage[this.rear] = element;
this.rear += 1;
}
// ๊ฐ์ฅ ๋์ค์ ์ถ๊ฐ๋ ๋ฐ์ดํฐ๊ฐ ๊ฐ์ฅ ๋จผ์ ๋์์ผ ํ๋ค.
// queue์์ element๋ฅผ ์ ๊ฑฐ ํ ๋ค, ํด๋น element๋ฅผ return.
// ๋ง์ฝ size๊ฐ 0์ด๋ผ๋ฉด ์๋ฌด๊ฒ๋ return ํ์ง ์๋๋ค.
// this.front(๊ฐ์ฅ ๋จผ์ ์ถ๊ฐ๋ ๋ฐ์ดํฐ๊ฐ ์๋ index)๋ก ์ตํ๋จ์ ์ค์ ํ ํ ๋ณ์์ ์ ์ฅํ๊ณ , queue์์ ์ ๊ฑฐ.
// ํ๋๋ฅผ ์ ๊ฑฐํ์ผ๋ front+1(๋ค์ ์์์ index๋ก ์ ๊ทผํ๊ธฐ ์ํจ)
dequeue() {
if (this.size() <= 0) {
return;
}
const result = this.storage[this.front];
delete this.storage[this.front];
this.front += 1;
return result;
}
}
// ์
์ถ๋ ฅ
const queue = new Queue();
queue.size(); // 0
for(let i = 1; i < 10; i++) {
queue.enqueue(i);
}
queue.dequeue(); // 1
queue.dequeue(); // 2
queue.size(); // 7
queue.enqueue(10);
queue.size(); // 8
queue.dequeue(); // 3
queue.dequeue(); // 4
queue.size(); // 6
...
Printer์์ ์ฌ๋ฌ ๋ฌธ์๋ฅผ ์์๋๋ก ์ธ์ํ๋ ค๋ฉด ์๋์ ๊ณผ์ ์ ๊ฑฐ์น๋ค.
๋ฌธ์ ์์ฑ ํ, ์ถ๋ ฅ ๋ฒํผ ๋๋ฅด๊ธฐ -> ํด๋น ๋ฌธ์๊ฐ ์ธ์ ์์ (์์ ๊ธฐ์ต ์ฅ์น์) queue๋ก ๋ค์ด๊ฐ๋ค.
์ธ์ ์์ queue์ ๋ค์ด์จ ๋ฌธ์์ ์์๋๋ก ์ธ์ํ๋ค.
์์ ๊ฐ์ด ๋ฐ์ดํฐ๋ฅผ ์ฃผ๊ณ ๋ฐ์ ๋, ๊ฐ ์ฅ์น ์ฌ์ด์ ์๋๋ ์๊ฐ์ ์ฐจ์ด๋ฅผ ๊ทน๋ณตํ๊ณ ์์๋๋ก ๊ฒฐ๊ณผ๋ฌผ์ ์ถ๋ ฅํ๊ธฐ ์ํด ์์ ๊ธฐ์ต ์ฅ์น์ ์๋ฃ๊ตฌ์กฐ๋ก Queue๋ฅผ ์ฌ์ฉํ๋ฉฐ, ํตํ์ด ๋ฒํผ(buffer) ๋ผ๊ณ ๋ถ๋ฅธ๋ค.
function queuePrinter(bufferSize, capacities, documents) {
// ํ์ํ ๋ณ์๋ค ์ ์ธ
// time = ์๊ฐ์ด ์ผ๋ง๋ ์ง๋ฌ๋์ง ๊ธฐ๋ก
let time = 0
// queue = ์ธ์ ๋๊ธฐ ๋ชฉ๋ก
let queue = []
// total = ๋๊ธฐ ๋ชฉ๋ก(queue)์ ๋ค์ด์๋ ๋ฌธ์์ ์ด ์ฉ๋
let total = 0
// go = 1์ด๋ง๋ค ๋ฒ์ด์ง ์ผ์ ๋ด์ ํจ์
const go = () => {
// 1์ด ์ง๋จ
time += 1
// ๋๊ธฐ ๋ชฉ๋ก ๋งจ ์์ ์๋ ๋ฌธ์๋ฅผ ๋นผ์ printed๋ผ๋ ๋ณ์์ ๋ด๊ธฐ
let printed = queue.shift()
// ํ๋ฆฐํธํ ๋ฌธ์๊ฐ ์์๋ค๋ฉด printed๋ผ๋ ๋ณ์์ ๊ฐ์ด ์กด์ฌ
// ๊ฐ = ์ธ์๋ ๋ฌธ์์ ์ฉ๋
// ๋ฐ๋ผ์ ์ด ์ฉ๋ total์์ ์ธ์๋ ๋ฌธ์ ์ฉ๋์ ๋นผ์ค๋ค
if(printed){
total = total - printed;
}
// ๋๊ธฐ ๋ชฉ๋ก์ ๋ค๋ฅธ ๋ฌธ์๋ฅผ ์ฌ๋ฆด ์ ์๋์ง ํ์ธ
// ์ด ์ฉ๋ + ์ธ์ํด์ผ ํ ๋ฆฌ์คํธ 0๋ฒ์งธ ๋ฌธ์์ ์ฉ๋์ capacities์ ๊ฐ๋ณด๋ค ๊ฐ๊ฑฐ๋ ์์์ผ ํจ.
if (total + documents[0] <= capacities) {
// ๋ฆฌ์คํธ์ ์๋ ๋ฌธ์๋ฅผ ๋นผ์
let document = documents.shift()
// ๋๊ธฐ ๋ชฉ๋ก ๋ง์ง๋ง ์นธ์ ๋ฌธ์๋ฅผ ๋ฃ์ด์ฃผ๊ณ
queue[bufferSize-1] = document
// ์ด ์ฉ๋ + ๋ฃ์ด์ค ๋ฌธ์ ์ฉ๋
total += document
}
}
// ๋ฌธ์๋ฆฌ์คํธ์ ๋ฌธ์๊ฐ ์๊ฑฐ๋,
// ์ธ์ ๋๊ธฐ ๋ชฉ๋ก์ ์์ง ์ธ์๋์ง ์์ ๋ฌธ์๊ฐ ๋จ์์์ ๋
while (documents.length || queue.length) {
// 1์ด๋ง๋ค ๋ฒ์ด์ง ์ผ์ ๋ด์ ํจ์๋ฅผ ์คํ์์ผ์ค
go()
}
// ๋ ์ด์ ์ธ์ํ ๋ฌธ์๋, ์ธ์ ๋๊ธฐ์ค์ธ ๋ฌธ์๋ ์์ ๋
// ์ด ์๋ชจ์๊ฐ์ธ time์ return
return time
}
// ์
์ถ๋ ฅ
let bufferSize = 2;
let capacities = 10;
let documents = [7, 4, 5, 6];
let output = queuePrinter(bufferSize, capacities, documents);
console.log(output) // 8
Reference: ์ฝ๋์คํ ์ด์ธ