1
class Queue {
2
  // 생성자: new 키워드로 객체를 생성할때 호출되는 함수
3
  constructor() {
4
    this.queue = [] // 요소를 넣을 배열 변수
5
    this.front = 0 // front 포인터
6
    this.rear = 0 // rear 포인터
7
  }
8
  // 📝 넣기
9
  enqueue(value) {
10
    // 실행노드[rear변수 증감] = 입력받은 값
11
    this.queue[this.rear++] = value
12
  }
13

14
  // 📝 빼기
15
  dequeue() {
16
    const value = this.queue[this.front] // 실행노드[front값]을 받아오기
17
    delete this.queue[this.front] // 실행노드의 front 삭제
18
    this.front += 1
19
    return value
20
  }
21

22
  // 📝 큐의 가장 앞에 있는 노드 반환
23
  peek() {
24
    return this.queue[this.front]
25
  }
26

27
  // 📝 큐의 크기 반환
28
  size() {
29
    return this.rear - this.front
30
  }
31
}
32

33
const queue = new Queue()
34
queue.enqueue(1)
35
queue.enqueue(2)
36
queue.enqueue(4)
37
console.log(queue.dequeue()) // 1
38
queue.enqueue(8)
39
console.log(queue.size()) // 3
40
console.log(queue.peek()) // 2
41
console.log(queue.dequeue()) // 2
42
console.log(queue.dequeue()) // 4

1
class Node {
2
  // 생성자: new 키워드로 객체를 생성할때 호출되는 함수
3
  constructor(value) {
4
    this.value = value
5
    this.next = null
6
  }
7
}
8

9
class Queue {
10
  constructor() {
11
    this.head = null
12
    this.tail = null
13
    this.size = 0
14
  }
15

16
  // 📝 넣기
17
  enqueue(newValue) {
18
    const newNode = new Node(newValue)
19
    // 해당 큐가 빈 노드라면
20
    if (this.head == null) {
21
      this.head = this.tail = newNode
22
    } else {
23
      this.tail.next = newNode
24
      this.tail = newNode
25
    }
26
    this.size += 1
27
  }
28

29
  // 📝 빼기
30
  dequeue() {
31
    const value = this.head.value
32
    this.head = this.head.next
33
    this.size -= 1
34
    return value
35
  }
36

37
  // 📝 큐의 가장 앞에 있는 노드 반환
38
  peek() {
39
    return this.head.value
40
  }
41

42
  // 📝 큐의 크기 반환
43
  size() {
44
    return this.rear - this.front
45
  }
46
}
47

48
const queue = new Queue()
49
queue.enqueue(1)
50
queue.enqueue(2)
51
queue.enqueue(4)
52
console.log(queue.dequeue()) // 1
53
queue.enqueue(8)
54
console.log(queue.size()) // 3
55
console.log(queue.peek()) // 2
56
console.log(queue.dequeue()) // 2
57
console.log(queue.dequeue()) // 4

1
const queue = [1, 2, 3]
2
queue.push(4)
3
const value = queue.shift() // O(n) !!
4
console.log(value) // 1

1
class Queue {
2
  // 생성자: new 키워드로 객체를 생성할때 호출되는 함수
3
  constructor(maxSize) {
4
    this.maxSize = maxSize
5
    this.queue = []
6
    this.front = 0
7
    this.rear = 0
8
    this.size = 0
9
  }
10

11
  // 📝 넣기
12
  enqueue(value) {
13
    if (this.isFull()) {
14
      console.log('Queue is full.')
15
      return
16
    }
17
    this.queue[this.rear] = value
18
    this.rear = (this.rear + 1) % this.maxSize
19
    this.size += 1
20
  }
21

22
  // 📝 빼기
23
  dequeue() {
24
    const value = this.queue[this.front]
25
    delete this.queue[this.front]
26
    this.front = (this.front + 1) % this.maxSize
27
    this.size -= 1
28
    return value
29
  }
30

31
  isFull() {
32
    return this.size === this.maxSize
33
  }
34

35
  // 📝 큐의 가장 앞에 있는 노드 반환
36
  peek() {
37
    return this.queue[this.front]
38
  }
39
}
40
const queue = new Queue(4)
41
queue.enqueue(1)
42
queue.enqueue(2)
43
queue.enqueue(4)
44
queue.enqueue(8)
45
queue.enqueue(16) // Queue is full.
46
console.log(queue.dequeue()) // 1
47
console.log(queue.dequeue()) // 2
48
console.log(queue.size) // 2
49
console.log(queue.peek()) // 4
50
queue.enqueue(16)
51
queue.enqueue(32)
52
console.log(queue.isFull()) // true

1
class Node {
2
  constructor(value) {
3
    this.value = value
4
    this.next = null
5
  }
6
}
7
class Queue {
8
  constructor() {
9
    this.head = null
10
    this.tail = null
11
  }
12
  enqueue(newValue) {
13
    const newNode = new Node(newValue)
14
    if (this.head === null) {
15
      this.head = this.tail = newNode
16
    } else {
17
      this.tail.next = newNode
18
      this.tail = newNode
19
    }
20
  }
21
  dequeue() {
22
    const value = this.head.value
23
    this.head = this.head.next
24
    return value
25
  }
26
  peek() {
27
    return this.head.value
28
  }
29
}
30

31
function solution(priorities, location) {
32
  const queue = new Queue() // 큐 생성
33

34
  // 대기목록만큼 순회
35
  for (let i = 0; i < priorities.length; i += 1) {
36
    queue.enqueue([priorities[i], i]) // 각각의 우선순위와 인덱스
37
  }
38
  priorities.sort((a, b) => b - a) // 내림차순 정렬
39

40
  let count = 0 // 내가 인쇄를 요청한 문서가 몇 번째로 인쇄되는지
41

42
  // 큐가 비어있을 떄까지 반복
43
  while (true) {
44
    const currentValue = queue.peek() // 가장 앞에 노드 반환
45

46
    // 지금까지 수행한 우선순위보다 작은 경우
47
    if (currentValue[0] < priorities[count]) {
48
      queue.enqueue(queue.dequeue()) // 그 값을 맨 뒤에 넣기
49
    } else {
50
      const value = queue.dequeue() // 우선순위가 더 큰 경우, 바로 dequeue
51
      count += 1
52

53
      // 뽑은 문서가 내가 찾은 문서라면
54
      if (location === value[1]) {
55
        return count
56
      }
57
    }
58
  }
59
}