[JS] 이중우선순위큐: 비겁한 정렬은 이제 그만! 당당히 힙으로 맞서 싸워!

안녕하세요.

어제 공유드린 제가 새로 짠 힙을 응용할 시간이 되었군요.

[JS] 힙/우선 순위 큐 새로 짜봤습니다.

문제는 되게 쉽습니다. 같이 한 번 볼까요?

---

문제 요약

이중 우선순위 큐는 다음 연산을 할 수 있는 자료구조를 말합니다.

I 숫자	큐에 주어진 숫자를 삽입합니다.
D 1	큐에서 최댓값을 삭제합니다.
D -1	큐에서 최솟값을 삭제합니다.

이중 우선순위 큐가 할 연산 operations가 매개변수로 주어질 때, 모든 연산을 처리한 후 큐가 비어있으면 [0,0] 비어있지 않으면 [최댓값, 최솟값]을 return 하도록 solution 함수를 구현해주세요.

제한사항

• operations는 길이가 1 이상 1,000,000 이하인 문자열 배열입니다.
• operations의 원소는 큐가 수행할 연산을 나타냅니다.
  • 원소는 “명령어 데이터” 형식으로 주어집니다.- 최댓값/최솟값을 삭제하는 연산에서 최댓값/최솟값이 둘 이상인 경우, 하나만 삭제합니다.
• 빈 큐에 데이터를 삭제하라는 연산이 주어질 경우, 해당 연산은 무시합니다.

테스트케이스

testcase	return
["I 16", "I -5643", "D -1", "D 1", "D 1", "I 123", "D -1"]	[0, 0]
["I -45", "I 653", "D 1", "I -642", "I 45", "I 97", "D 1", "D -1", "I 333"]	[333, -45]

 

접근 방법

수많은 코딩 테스트를 다루는 블로그들이 이 문제를

단지 정렬이 된다는 이유로 힙을 쓰지 않고 그냥 넘겼는데요.

전 이런 비겁함 용납불가능합니다.

 

이런 연습에서도 힙을 쓰지 않는다면 실전에서 힙을 만났을 때 자바스크립트 쓴다고 넘기실 건가요?언젠간 마주치게 됩니다. 꼭 힙을 써서 풀어주세요.그게 바로 접근 방법입니다.

 

정답 코드

class MinHeap {
    constructor() {
        this.heap = [null];
    }
    
    push(val) {
        this.heap.push(val);
        let currentIndex = this.heap.length - 1;
        let parentIndex = Math.floor(currentIndex / 2);
        
        while (parentIndex !== 0 && this.heap[currentIndex] < this.heap[parentIndex]) {
            this._swap(currentIndex, parentIndex);
            currentIndex = parentIndex;
            parentIndex = Math.floor(currentIndex / 2);
        }
    }
    
    pop(isTopPop) {
        if (this.isEmpty()) return;
        if (this.heap.length === 2) return this.heap.pop();
        if (!isTopPop) {
            const parentIndex = Math.floor((this.heap.length - 1) / 2);
            const lastLeaf = this.heap.slice(parentIndex);
            const max = Math.max(...lastLeaf);
            this._swap(parentIndex + lastLeaf.indexOf(max), this.heap.length - 1);
            return this.heap.pop();
        }
        
        const val = this.heap[1];
        this.heap[1] = this.heap.pop();
        
        let currentIndex = 1;
        let leftIndex = 2;
        let rightIndex = 3;
        
        while (
            this.heap[leftIndex] && this.heap[currentIndex] > this.heap[leftIndex] ||
            this.heap[rightIndex] && this.heap[currentIndex] > this.heap[rightIndex] 
        ) {
            if (this.heap[leftIndex] === undefined) {
                this._swap(rightIndex, currentIndex);
            } else if (this.heap[rightIndex] === undefined) {
                this._swap(leftIndex, currentIndex);
            } else if (this.heap[leftIndex] > this.heap[rightIndex]) {
                this._swap(currentIndex, rightIndex);
                currentIndex = rightIndex;
            } else if (this.heap[leftIndex] <= this.heap[rightIndex]) {
                this._swap(currentIndex, leftIndex);
                currentIndex = leftIndex;
            }
            
            leftIndex = currentIndex * 2;
            rightIndex = currentIndex * 2 + 1;
        }
        
        return val;
    }
    
    isEmpty() {
        return this.heap.length === 1;
    }
    
    result() {
        if (this.heap.length === 1) return [0, 0];
        if (this.heap.length === 2) return [this.heap[1] ,this.heap[1]];
        const parentIndex = Math.floor((this.heap.length - 1) / 2);
        const lastLeaf = this.heap.slice(parentIndex);
        const max = Math.max(...lastLeaf);
        return [max, this.heap[1]];
    }
    
    _swap(a, b) {
        [this.heap[a], this.heap[b]] = [this.heap[b], this.heap[a]];
    }
}

function solution(operations) {
    const minHeap = new MinHeap();
    
    operations.forEach((operation) => {
        const [type, val] = operation.split(" ").map((v, i) => i === 1 ? Number(v) : v);
        if (type === "I") {
            minHeap.push(val);
        } else {
            minHeap.pop(val < 0);
        }
    });
    return minHeap.result();
}

실행결과

팁 1. 최소 힙에서 최댓 값 찾기

제가 저번 힙을 설명하는 포스트 하단에서

최소힙에서 최댓값을 접근하거나 최대힙에서 최솟값을 접근하는 경우에는

최하단 depth의 노드를 확인하면 된다고 공유드렸습니다.

 

이 문제에서 그대로 적용 한 번 해보죠!

const parentIndex = Math.floor((this.heap.length - 1) / 2);
const lastLeaf = this.heap.slice(parentIndex);
const max = Math.max(...lastLeaf);
this._swap(parentIndex + lastLeaf.indexOf(max), this.heap.length - 1);
return this.heap.pop();

 

이해가 가실까요?

가장 마지막 index를 기준으로 바로 위쪽의 부모 노드를 구해줍니다.

그 노드부터 끝까지 slice를 해준다면 이 값들이 이 heap에서 가장 큰 값임이 보장됩니다.

최댓값을 가진 노드와 heap의 끝에 있는 노드를 교환해주는 로직으로 전 pop을 구현했습니다.

 

팁 2. 최소힙의 result에서도 똑같은 최댓값 찾기

result() {
    if (this.heap.length === 1) return [0, 0];
    if (this.heap.length === 2) return [this.heap[1] ,this.heap[1]];
    const parentIndex = Math.floor((this.heap.length - 1) / 2);
    const lastLeaf = this.heap.slice(parentIndex);
    const max = Math.max(...lastLeaf);
    return [max, this.heap[1]];
}

힙의 길이에 따라 적절한 return을 해줍니다.

값이 하나라면 최솟값과 최댓값이 같겠군요.

그리고 2개 이상일 때는 아까 구했던 로직을 그대로 이용하면 최댓값을 구해줄 수 있습니다.

 

정공법으로 연습해야 실력이 된다고 믿습니다.

 

그럼 이만!