CodeGym /Java Blog /๋ฌด์ž‘์œ„์˜ /์˜ˆ์ œ๊ฐ€ ์žˆ๋Š” Java์˜ ์ตœ์†Œ ํž™
John Squirrels
๋ ˆ๋ฒจ 41
San Francisco

์˜ˆ์ œ๊ฐ€ ์žˆ๋Š” Java์˜ ์ตœ์†Œ ํž™

๋ฌด์ž‘์œ„์˜ ๊ทธ๋ฃน์— ๊ฒŒ์‹œ๋˜์—ˆ์Šต๋‹ˆ๋‹ค
์‹œ์ž‘ํ•˜๊ธฐ ์ „์— ์ด์ง„ ํŠธ๋ฆฌ (์ด์ง„ ํŠธ๋ฆฌ์—์„œ ๊ฐ ๋…ธ๋“œ๋Š” ์™ผ์ชฝ ํ•˜์œ„ ํŠธ๋ฆฌ ์˜ ๋ชจ๋“  ํ‚ค๋ณด๋‹ค ํฌ๊ณ  ์˜ค๋ฅธ์ชฝ ํ•˜์œ„ ํŠธ๋ฆฌ ์˜ ๋ชจ๋“  ํ‚ค๋ณด๋‹ค ์ž‘์€ ํ‚ค ๋ฅผ ์ €์žฅํ•จ ) ์— ๋Œ€ํ•ด ์•Œ๊ณ  ์žˆ๋‹ค๊ณ  ๊ฐ€์ •ํ•ฉ๋‹ˆ๋‹ค . ๋ฐ˜๋ฉด ์ด์ง„ ํž™์€ ์ตœ์†Œ ํž™ ๋˜๋Š” ์ตœ๋Œ€ ํž™ ์ˆœ์„œ ์†์„ฑ์„ ๋งŒ์กฑํ•˜๋Š” ์™„์ „ํ•œ ์ด์ง„ ํŠธ๋ฆฌ์ž…๋‹ˆ๋‹ค.. ์ด๋Ÿฌํ•œ ๊ฐœ๋…์— ์ต์ˆ™ํ•˜์ง€ ์•Š์€ ๊ฒฝ์šฐ ์ด๋Ÿฌํ•œ ๊ฐœ๋…์„ ์ „์ œ ์กฐ๊ฑด์œผ๋กœ ์ดํ•ดํ•˜๋Š” ๊ฒƒ์ด ์ข‹์Šต๋‹ˆ๋‹ค. ๋งŽ์€ ์ดˆ๋ณด ํ”„๋กœ๊ทธ๋ž˜๋จธ๋Š” ํž™, ์ตœ์†Œ ํž™ ๋ฐ ์šฐ์„  ์ˆœ์œ„ ํ์˜ ๊ฐœ๋…์œผ๋กœ ์–ด๋ ค์›€์„ ๊ฒช์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด ๊ฒŒ์‹œ๋ฌผ์—์„œ๋Š” ํž™์ด Min-Heap๊ณผ ์–ด๋–ป๊ฒŒ ๋‹ค๋ฅธ์ง€, ์šฐ์„  ์ˆœ์œ„ ํ๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ Min Heap์„ ๊ตฌํ˜„ํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ์ž์„ธํžˆ ์•Œ์•„๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

์ตœ์†Œ ํž™์ด๋ž€ ๋ฌด์—‡์ž…๋‹ˆ๊นŒ?

์ตœ์†Œ ํž™์€ 'n' ์ˆ˜์ค€์˜ ๋ชจ๋“  ๋…ธ๋“œ๊ฐ€ 'n+1' ์ˆ˜์ค€์˜ ์ž์‹ ๋…ธ๋“œ๋ณด๋‹ค ์ž‘๊ฑฐ๋‚˜ ๊ฐ™์€ ๊ฐ’์„ ์ €์žฅํ•˜๋Š” ์†์„ฑ์„ ๊ฐ€์ง€๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค. ๋ฃจํŠธ๋Š” ์ž์‹๋ณด๋‹ค ์ž‘๊ฑฐ๋‚˜ ๊ฐ™์€ ๊ฐ’์„ ๊ฐ–๊ณ , ์ฐจ๋ก€๋กœ ์ž์‹๋ณด๋‹ค ์ž‘๊ฑฐ๋‚˜ ๊ฐ™์€ ๊ฐ’์„ ๊ฐ–๊ธฐ ๋•Œ๋ฌธ์— ๋ฃจํŠธ๋Š” ํŠธ๋ฆฌ์˜ ๋ชจ๋“  ๊ฐ’ ์ค‘ ์ตœ์†Œ๊ฐ’์„ ์ €์žฅํ•ฉ๋‹ˆ๋‹ค.

์˜ˆ

์˜ˆ์ œ๊ฐ€ ํฌํ•จ๋œ Java์˜ ์ตœ์†Œ ํž™ - 2
๊ทธ๋ฆผ 1: ๊ฐ„๋‹จํ•œ ์ตœ์†Œ ํž™
๋…ธ๋“œ์˜ ๊ฐ’๊ณผ ์ตœ์†Œ ํž™ ๋˜๋Š” ์ตœ๋Œ€ ํž™์˜ ํ˜•์ œ ๊ฐ’ ์‚ฌ์ด์— ํ•„์š”ํ•œ ๊ด€๊ณ„๊ฐ€ ์—†์Œ์— ์œ ์˜ํ•˜์‹ญ์‹œ์˜ค. ์˜ˆ๋ฅผ ๋“ค์–ด ๋ฃจํŠธ์˜ ์™ผ์ชฝ ํ•˜์œ„ ํŠธ๋ฆฌ์— ์žˆ๋Š” ๋ชจ๋“  ๋…ธ๋“œ์˜ ๊ฐ’์ด ์˜ค๋ฅธ์ชฝ ํ•˜์œ„ ํŠธ๋ฆฌ์˜ ๋ชจ๋“  ๋…ธ๋“œ์— ๋Œ€ํ•œ ๊ฐ’๋ณด๋‹ค ํด ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.์˜ˆ์ œ๊ฐ€ ํฌํ•จ๋œ Java์˜ ์ตœ์†Œ ํž™ - 3
๊ทธ๋ฆผ 2: ์™ผ์ชฝ ์ž์‹ ๋…ธ๋“œ > ์˜ค๋ฅธ์ชฝ ์ž์‹ ๋…ธ๋“œ๊ฐ€ ์žˆ๋Š” ์ตœ์†Œ ํž™

Java์˜ ์ตœ์†Œ ํž™ ํ‘œํ˜„

์ตœ์†Œ ํž™์„ ๋‚˜ํƒ€๋‚ด๋Š” ๋ฐ ๊ฐ€์žฅ ์ผ๋ฐ˜์ ์œผ๋กœ ์‚ฌ์šฉ๋˜๋Š” ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ๋Š” ๊ฐ„๋‹จํ•œ ๋ฐฐ์—ด์ž…๋‹ˆ๋‹ค. ์ดˆ๋ณด์ž๋กœ์„œ "๋ฐฐ์—ด"๊ณผ "์ตœ์†Œ ํž™"์„ ํ˜ผ๋™ํ•  ํ•„์š”๊ฐ€ ์—†์Šต๋‹ˆ๋‹ค. ์ตœ์†Œ ํž™์˜ ๋…ธ๋“œ/์š”์†Œ ๊ฐ’์ด ๋ฐฐ์—ด์— ์ €์žฅ๋˜๋Š” ๊ฒƒ์œผ๋กœ ๋ณผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค . Java์— " ํŠธ๋ฆฌ " ๋ฅผ ์ €์žฅํ•  ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ๊ฐ€ ์—†๊ณ  ์ด๋ฅผ ์œ„ํ•ด "๋…ธ๋“œ"๋ฅผ ๊ตฌ์ถ•ํ•˜๊ฑฐ๋‚˜ " ๊ทธ๋ž˜ํ”„ "๋ฅผ ์ €์žฅํ•˜๊ธฐ ์œ„ํ•ด "๋งต"์„ ์‚ฌ์šฉํ•˜๋Š” ๋ฐฉ์‹๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค .์˜ˆ์ œ๊ฐ€ ํฌํ•จ๋œ Java์˜ ์ตœ์†Œ ํž™ - 4
๊ทธ๋ฆผ 3: ๊ทธ๋ฆผ 2์˜ ํž™ ๋ฐฐ์—ด ํ‘œํ˜„
๋‹ค์Œ ์ˆ˜์‹์„ ์‚ฌ์šฉํ•˜์—ฌ ๋ถ€๋ชจ, ์˜ค๋ฅธ์ชฝ ๋˜๋Š” ์™ผ์ชฝ ์ž์‹ ๋…ธ๋“œ์— ๊ฐ„๋‹จํžˆ ์•ก์„ธ์Šคํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ์‹œ์—ฐํ•  ๊ฒƒ์ž…๋‹ˆ๋‹ค.
  • minHeap []์€ ์ธ๋ฑ์Šค " i = 0 ์— ๋ฃจํŠธ๊ฐ€ ์žˆ๋Š” ์ •์ˆ˜ ๋ฐฐ์—ด์ž…๋‹ˆ๋‹ค . ".
  • minHeap[(i - 1) / 2]๋Š” ๋ถ€๋ชจ ๋…ธ๋“œ๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
  • minHeap[(i * 2) + 2]๋Š” ์˜ค๋ฅธ์ชฝ ์ž์‹ ๋…ธ๋“œ๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
  • minHeap[(i * 2) + 1]์€ ์™ผ์ชฝ ์ž์‹ ๋…ธ๋“œ๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
์œ„์˜ ๊ทธ๋ฆผ #2๋ฅผ ๋ณด๋ฉด ๋ฃจํŠธ(๋ถ€๋ชจ)=3, ์™ผ์ชฝ ์ž์‹ ๋…ธ๋“œ๋Š” 13, ์˜ค๋ฅธ์ชฝ ์ž์‹ ๋…ธ๋“œ=7์˜ ๊ฐ’์ด ๋ฉ๋‹ˆ๋‹ค.

Java์—์„œ ์ตœ์†Œ ํž™ ๊ตฌํ˜„ - ๋ฐฐ์—ด ์‚ฌ์šฉ

์ถ”๊ฐ€ํ•  ์š”์†Œ์˜ ํ˜„์žฌ ์œ„์น˜๋ฅผ ์ธ๋ฑ์Šค๋กœ, ๋ฐฐ์—ด์˜ ์ „์ฒด ํฌ๊ธฐ๋ฅผ ํฌ๊ธฐ๋กœ ํ•˜๋Š” ๋ฐฐ์—ด์„ ์‚ฌ์šฉํ•˜๋Š” ํž™์˜ ๊ธฐ๋ณธ ๊ตฌํ˜„์„ ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

import java.util.Arrays;
public class MinHeap 
{
	private int[] Heap;
	private int index;
	private int size;

	public MinHeap(int size) {
		this.size = size;
		this.index = 0;
		Heap = new int[size];
	}

	private int parent(int i) {
		return (i - 1) / 2;
	}

	private int leftChild(int i) {
		return (i * 2) + 1;
	}

	private int rightChild(int i) {
		return (i * 2) + 2;
	}

	private boolean isLeaf(int i) {
		if (rightChild(i) >= size || leftChild(i) >= size) {
			return true;
		}
		return false;
	}

	public void insert(int element) {
		if (index >= size) {
			return;
		}
		Heap[index] = element;
		int current = index;

		while (Heap[current] < Heap[parent(current)]) {
			swap(current, parent(current));
			current = parent(current);
		}
		index++;
	}

	// removes and returns the minimum element from the heap
	public int remove() {
     // since its a min heap, so root = minimum
		int popped = Heap[0]; 
		Heap[0] = Heap[--index];
		minHeapify(0);
		return popped;
	}

	// heapify the node at i
	private void minHeapify(int i) {
	// If the node is a non-leaf node and any of its child is smaller
		if (!isLeaf(i)) {
			if (Heap[i] > Heap[leftChild(i)] || 
                  Heap[i] > Heap[rightChild(i)]) {
				if (Heap[leftChild(i)] < Heap[rightChild(i)]) {
					swap(i, leftChild(i));
					minHeapify(leftChild(i));
				} else {
					swap(i, rightChild(i));
					minHeapify(rightChild(i));
				}
			}
		}
	}

	// builds the min-heap using the minHeapify
	public void minHeap() {
		for (int i = (index - 1 / 2); i >= 1; i--) {
			minHeapify(i);
		}
	}

     // Function to print the contents of the heap
	public void printHeap() {
		for (int i = 0; i < (index / 2); i++) {
			System.out.print("Parent : " + Heap[i]);
			if (leftChild(i) < index)
				System.out.print(" Left : " + Heap[leftChild(i)]);
			if (rightChild(i) < index)
				System.out.print(" Right :" + Heap[rightChild(i)]);
			System.out.println();
		}
	}
	// swaps two nodes of the heap
	private void swap(int x, int y) {
		int tmp;
		tmp = Heap[x];
		Heap[x] = Heap[y];
		Heap[y] = tmp;
	}
	public static void main(String[] arg) 
      {
	    MinHeap minHeap = new MinHeap(7);
	    minHeap.insert(3);
	    minHeap.insert(13);
	    minHeap.insert(7);
          minHeap.insert(16);
	    minHeap.insert(21);
	    minHeap.insert(12);
	    minHeap.insert(9);
	    minHeap.minHeap();

	   System.out.println("The Min Heap is : " + Arrays.toString(minHeap.Heap);
	   minHeap.printHeap();
	   System.out.println("\nThe Min Value is : " + minHeap.remove());
	   System.out.println("\nThe Min Heap is :"+ Arrays.toString(minHeap.Heap));
	   minHeap.printHeap();
	}
}
์‚ฐ์ถœ
์ตœ์†Œ ํž™: [3, 13, 7, 16, 21, 12, 9] ๋ถ€๋ชจ: 3 ์™ผ์ชฝ: 13 ์˜ค๋ฅธ์ชฝ:7 ๋ถ€๋ชจ: 13 ์™ผ์ชฝ: 16 ์˜ค๋ฅธ์ชฝ:21 ๋ถ€๋ชจ: 7 ์™ผ์ชฝ: 12 ์˜ค๋ฅธ์ชฝ:9 ์ตœ์†Œ๊ฐ’ is : 3 Min Heap is : [7, 13, 9, 16, 21, 12, 9] // ๋ฃจํŠธ๋ฅผ ์ œ๊ฑฐํ•œ ํ›„ Parent : 7 Left : 13 Right :9 Parent : 13 Left : 16 Right :21 Parent : 9 ์™ผ์ชฝ : 12

์šฐ์„ ์ˆœ์œ„ ๋Œ€๊ธฐ์—ด

์šฐ์„  ์ˆœ์œ„ ๋Œ€๊ธฐ์—ด์€ ๊ฐ ์š”์†Œ๊ฐ€ ์šฐ์„  ์ˆœ์œ„ ์™€ ์—ฐ๊ฒฐ๋˜๊ณ  ํ•ด๋‹น ์šฐ์„  ์ˆœ์œ„์— ๋”ฐ๋ผ ๋ฐฐ์น˜๋˜๋Š” ํŠน๋ณ„ํ•œ ์œ ํ˜•์˜ ๋Œ€๊ธฐ์—ด์ž…๋‹ˆ๋‹ค . ์ตœ์†Œ ํž™์„ ๋” ์‰ฝ๊ฒŒ ๊ตฌํ˜„ํ•˜๊ธฐ ์œ„ํ•ด Java์—์„œ ์ œ๊ณตํ•˜๋Š” PriorityQueue ํด๋ž˜์Šค java.util.PriorityQueue ๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค . ์ฃผ์–ด์ง„ ์š”์†Œ๊ฐ€ ์šฐ์„  ์ˆœ์œ„์— ์ •๋ ฌ/๋ฐฐ์น˜๋˜์–ด์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ ์šฐ์„  ์ˆœ์œ„ ํ๊ฐ€ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ์šฐ์„ ์ˆœ์œ„ ๋Œ€๊ธฐ์—ด์€ ํ‘œ์ค€ ๋Œ€๊ธฐ์—ด์ด FIFO(First-In-First-Out ) ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ๋”ฐ๋ฅด๊ธฐ ๋•Œ๋ฌธ์— ๋‹จ์ˆœํ•œ ๋Œ€๊ธฐ์—ด๊ณผ ๋‹ค๋ฆ…๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ๋•Œ๋กœ๋Š” ๋Œ€๊ธฐ์—ด์˜ ์š”์†Œ๊ฐ€ ์šฐ์„ ์ˆœ์œ„์— ๋”ฐ๋ผ ์ฒ˜๋ฆฌ๋˜์–ด์•ผ ํ•˜๊ธฐ ๋•Œ๋ฌธ์— ์šฐ์„ ์ˆœ์œ„ ๋Œ€๊ธฐ์—ด์ด ์„ค๊ณ„๋˜์—ˆ์Šต๋‹ˆ๋‹ค. ์šฐ์„ ์ˆœ์œ„ ํ์— ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๋ฉด ๊ธฐ๋ณธ์ ์œผ๋กœ ์ตœ์†Œ ํž™์ด ์ƒ์„ฑ๋ฉ๋‹ˆ๋‹ค.

๊ณตํ†ต ์ž‘์—…

๊ตฌํ˜„์œผ๋กœ ์ด๋™ํ•˜๊ธฐ ์ „์— ์•Œ์•„์•ผ ํ•  java.util.PriorityQueue ์˜ ๋ช‡ ๊ฐ€์ง€ ์ผ๋ฐ˜์ ์ธ ์ž‘์—…์ด ์žˆ์Šต๋‹ˆ๋‹ค.
  • add(int ์š”์†Œ) ์ง€์ •๋œ ์š”์†Œ๋ฅผ ์šฐ์„  ์ˆœ์œ„ ๋Œ€๊ธฐ์—ด์— ์‚ฝ์ž…ํ•ฉ๋‹ˆ๋‹ค.
  • remove(int element)๋Š” ์ง€์ •๋œ ์š”์†Œ๊ฐ€ ์žˆ๋Š” ๊ฒฝ์šฐ ์ด ๋Œ€๊ธฐ์—ด์—์„œ ๋‹จ์ผ ์ธ์Šคํ„ด์Šค๋ฅผ ์ œ๊ฑฐํ•ฉ๋‹ˆ๋‹ค.
  • peek() ๋Š” ์ด ๋Œ€๊ธฐ์—ด์˜ ํ—ค๋“œ๋ฅผ ๊ฒ€์ƒ‰ํ•˜์ง€๋งŒ ์ œ๊ฑฐํ•˜์ง€๋Š” ์•Š์Šต๋‹ˆ๋‹ค. ๋Œ€๊ธฐ์—ด์ด ๋น„์–ด ์žˆ์œผ๋ฉด null์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
  • poll()์€ ์ด ๋Œ€๊ธฐ์—ด์˜ ํ—ค๋“œ๋ฅผ ๊ฒ€์ƒ‰ ๋ฐ ์ œ๊ฑฐํ•˜๊ฑฐ๋‚˜ ์ด ๋Œ€๊ธฐ์—ด์ด ๋น„์–ด ์žˆ์œผ๋ฉด null์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
  • contains()๋Š” ์ด ๋Œ€๊ธฐ์—ด์— ์ง€์ •๋œ ์š”์†Œ๊ฐ€ ํฌํ•จ๋˜์–ด ์žˆ์œผ๋ฉด "true"๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
  • size()๋Š” ์ด ์šฐ์„  ์ˆœ์œ„ ํ/์ตœ์†Œ ํž™์˜ ์š”์†Œ ์ˆ˜๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

์šฐ์„  ์ˆœ์œ„ ๋Œ€๊ธฐ์—ด์„ ์‚ฌ์šฉํ•˜์—ฌ Java์—์„œ ์ตœ์†Œ ํž™ ๊ตฌํ˜„

๋‹ค์Œ์€ Java์˜ ์šฐ์„  ์ˆœ์œ„ ํ ํด๋ž˜์Šค๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์ตœ์†Œ ํž™์„ ๊ตฌํ˜„ํ•˜๋Š” ๋ฐฉ๋ฒ•์ž…๋‹ˆ๋‹ค.

import java.util.*;

class MinHeapPriorityQueue {

	static PriorityQueue minHeap = new PriorityQueue();

	public static void view() {
		for (Integer x : minHeap) {
			System.out.print(x + " ");
		}
		System.out.println();
	}

	public static void main(String args[]) {
		// using "add" operation to insert elements
		minHeap.add(3);
		System.out.print("minHeap.add(3) = ");
		view();
		minHeap.add(13);
		minHeap.add(7);
		minHeap.add(16);
		minHeap.add(21);
		minHeap.add(12);
		minHeap.add(9);

		// printing Min-Heap
		System.out.print("minHeap.view() = ");
		view();

		// using "peek" method to view the head
		System.out.println("minHeap.peek() = " + minHeap.peek());

		// using "poll" method to remove and retrieve the head
		minHeap.poll();
		System.out.print("minHeap.poll() = ");
		view();

		// using "remove" method to remove specified element
		minHeap.remove(7);
		System.out.print("minHeap.remove(7) = ");
		view();

		// Check if an element is present using contains()
		boolean elementFound = minHeap.contains(11);
		System.out.println("minHeap.contains(11) = " + elementFound);
		elementFound = minHeap.contains(16);
		System.out.println("minHeap.contains(16) = " + elementFound);
	}
}
์‚ฐ์ถœ
minHeap.add(3) = 3 minHeap.view() = 3 13 7 16 21 12 9 minHeap.peek() = 3 minHeap.poll() = 7 13 9 16 21 12 minHeap.remove(7) = 9 13 12 16 21 minHeap.contains(11) = ๊ฑฐ์ง“ minHeap.contains(16) = ์ฐธ

๊ฒฐ๋ก 

์ตœ์†Œ ํž™์€ ์ผ์ •ํ•œ ์‹œ๊ฐ„์— ์š”์†Œ ํ’€์—์„œ ๊ฐ€์žฅ ์ž‘์€ ์š”์†Œ๋ฅผ ๊ฒ€์ƒ‰ํ•˜๋Š” ๋ฐ ๋„๋ฆฌ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ์ด ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ์˜ ๋‹ค๋ฅธ ์‘์šฉ ํ”„๋กœ๊ทธ๋žจ์ด ๋งŽ์ด ์žˆ์ง€๋งŒ ์ด๋ฅผ ๊ตฌํ˜„ํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ์„ ํƒํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ž˜ํ•˜๋ ค๋ฉด ์ธ๋‚ด์‹ฌ์„ ๊ฐ€์ง€๊ณ  ์—ฐ์Šตํ•ด์•ผ ํ•œ๋‹ค๋Š” ๊ฒƒ์€ ๋งํ•  ํ•„์š”๋„ ์—†์Šต๋‹ˆ๋‹ค. ์ด์ œ ๊ทผ์œก์„ ์›€์ง์ด๊ณ  ์ผ์„ ์‹œ์ž‘ํ•ฉ์‹œ๋‹ค!
์ฝ”๋ฉ˜ํŠธ
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION