๐ ๋ฌธ์ ์์ฝ
ํด์๋งต(HashMap)์ ๋ด์ฅ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์์ด ์ง์ ๊ตฌํํ๋ ๋ฌธ์ ์ด๋ค.
๊ธฐ๋ณธ์ ์ผ๋ก put, get, remove์ ๊ธฐ๋ฅ์ ์ง์ํ๋ HashMap ํด๋์ค๋ฅผ ๋ง๋๋ ๊ฒ์ด ๋ชฉํ๋ค.
๐ง ์๊ตฌ ๊ธฐ๋ฅ
MyHashMap(): ํด์๋งต์ ์ด๊ธฐํํ๋ค.
void put(int key, int value): ํค-๊ฐ ์์ ์ฝ์
๋๋ ๊ฐฑ์
int get(int key): ํด๋น ํค๊ฐ ์กด์ฌํ๋ฉด ๊ฐ์ ๋ฐํ, ์์ผ๋ฉด -1
void remove(int key): ํค์ ๊ทธ์ ๋์ํ๋ ๊ฐ์ ์ญ์
๐ก ํด๊ฒฐ ์ ๋ต
๋ฐฉ๋ฒ 1: ๊ณ ์ ํฌ๊ธฐ ๋ฐฐ์ด ์ฌ์ฉ
- key์ ๋ฒ์๊ฐ 0~1,000,000์ด๊ธฐ ๋๋ฌธ์ ๋ฐฐ์ด ๊ธฐ๋ฐ ๊ตฌํ ๊ฐ๋ฅ
- ๋ฐฐ์ด ์ด๊ธฐํ ํ ๊ธฐ๋ณธ๊ฐ์
-1๋ก ์ค์
- ๊ฐ๋จํ์ง๋ง ๊ณต๊ฐ ํจ์จ์ฑ์ ๋จ์ด์ง
๋ฐฉ๋ฒ 2: ํด์ + ์ฒด์ด๋(์ฐ๊ฒฐ ๋ฆฌ์คํธ) ๋ฐฉ์
- ํด์ ์ถฉ๋์ ๊ณ ๋ คํด ๊ฐ ๋ฒํท์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ฅผ ์ ์ฅ
key % SIZE๋ก ์ธ๋ฑ์ค๋ฅผ ๊ณ์ฐํ์ฌ ์ถฉ๋ ๋ฐฉ์ง
Node ํด๋์ค๋ฅผ ๋ง๋ค์ด ์ฐ๊ฒฐ ๋ฆฌ์คํธ ๊ตฌ์ฑ
- ์ถฉ๋์ด ์ ์ผ๋ฉด ํ๊ท ์๊ฐ๋ณต์ก๋๋ O(1)
๐ง ๋ฐฐ์ด ์
- ํด์๋งต์ ๋ด๋ถ ์๋ ์๋ฆฌ์ ์ถฉ๋ ํด๊ฒฐ ๋ฐฉ์์ ์ง์ ๊ตฌํํ๋ฉด์ ํ์คํ ์ดํดํ ์ ์์๋ค.
- ์ฒด์ด๋ ๋ฐฉ์์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ฅผ ์ฌ์ฉํด ์ถฉ๋์ ์์ ํ๊ฒ ์ฒ๋ฆฌํ ์ ์๋ ๊ณ ์ ์ ์ธ ๋ฐฉ๋ฒ์ด๋ค.
- ๋ฐฐ์ด ๊ธฐ๋ฐ ๋ฐฉ์์ ๋งค์ฐ ๋จ์ํ์ง๋ง ๊ณต๊ฐ ๋ญ๋น๊ฐ ๋ง๊ธฐ ๋๋ฌธ์ ์ํฉ์ ๋ฐ๋ผ ์ ์ ํ ์ ํํด์ผ ํ๋ค.
- ์ง์ ๊ตฌํ ์ ํด์ ํจ์ ์ค๊ณ์ ์๋ฃ๊ตฌ์กฐ ์ ํ์ด ํต์ฌ์ด๋ค.
๐ ์๊ฐ/๊ณต๊ฐ ๋ณต์ก๋
| ์ฐ์ฐ | ์๊ฐ ๋ณต์ก๋ | ์ค๋ช
|
|---|
put | ํ๊ท O(1), ์ต์
O(n) | ์ฐ๊ฒฐ ๋ฆฌ์คํธ ์ถฉ๋ ์ ๊ธธ์ด๋งํผ ํ์ |
get | ํ๊ท O(1), ์ต์
O(n) | |
remove | ํ๊ท O(1), ์ต์
O(n) | |
| ๊ณต๊ฐ | O(n) | ์ ์ฅ๋๋ ํค-๊ฐ ์์ ๋น๋ก |
๐ป ์ฒด์ด๋ ๋ฐฉ์ ํต์ฌ ์ฝ๋ ์์ฝ (Java)
private static final int SIZE = 10000;
private Node[] buckets;
private static class Node {
int key, value;
Node next;
Node(int key, int value) {
this.key = key;
this.value = value;
}
}
private int getIndex(int key) {
return key % SIZE;
}
- put: ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ๋
ธ๋๋ฅผ ์ฐพ์์ ์์ผ๋ฉด ๊ฐฑ์ , ์์ผ๋ฉด ์ถ๊ฐ
- get: ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ฅผ ์ํํ๋ฉด์ key ์ผ์นํ๋ ๋
ธ๋ ํ์
- remove: key์ ํด๋นํ๋ ๋
ธ๋๋ฅผ ๋ฆฌ์คํธ์์ ์ ๊ฑฐ
๐ฏ ๋๋ ์
- ๋ด๋ถ ๊ตฌ์กฐ๋ฅผ ์ค์ค๋ก ๊ตฌํํด ๋ณด๋ ํด์๋งต์ด ์ผ๋ง๋ ํจ์จ์ ์ธ ์๋ฃ๊ตฌ์กฐ์ธ์ง ์ฒด๊ฐํ ์ ์์๋ค.
- ์ถฉ๋ ์ฒ๋ฆฌ, ๋ฒํท ์ฌ์ด์ฆ, ํด์ ํจ์ ์ค๊ณ ๋ฑ ์ค์ ๊ตฌํ์์ ๊ณ ๋ คํ ์์๊ฐ ๋ง๋ค๋ ๊ฒ์ ์๊ฒ ๋์๋ค.
- ๋จ์ํ ๋ฐฐ์ด ๊ธฐ๋ฐ ๊ตฌํ๋ถํฐ ์ฒด์ด๋ ๊ธฐ๋ฐ ํด์๋งต๊น์ง ํ์ฅ ํ์ต์ด ๊ฐ๋ฅํ ์ข์ ๋ฌธ์ ์๋ค.