- ๋ฐฐ์ด์ด๋ ๋ฌธ์์ด์ ๋ํ ๋ฌธ์ ๋ค์ ์๋ก ๋์ฒด ๊ฐ๋ฅํ๋ค.
-
ํด์ํ ์ด๋ธ(hash table)
- ํจ์จ์ ์ธ ํ์์ ์ํ ์๋ฃ๊ตฌ์กฐ
- ํค(key)๋ฅผ ๊ฐ(value)์ ๋์์ํด
-
๊ฐ๋จํ ๊ตฌํ๋ฐฉ๋ฒ: ์ฐ๊ฒฐ๋ฆฌ์คํธ(linked list) + ํด์ ์ฝ๋ ํจ์(hash code function)
-
ํด์ํ ์ด๋ธ์ ํค์ ๊ฐ์ ๋ฃ๋ ๊ณผ์
- ํค์ ํด์ ์ฝ๋๋ฅผ ๊ณ์ฐํ๋ค. ํค์ ์๋ฃํ์ ๋ณดํต int ๋๋ long์ด๋ค. ํค์ ๊ฐ์๋ ๋ฌดํํ์ง๋ง int์ ๊ฐ์๋ ์ ํํ๋ฏ๋ก ์๋ก ๋ค๋ฅธ ๋ ๊ฐ์ ํค๊ฐ ๊ฐ์ ํด์ ์ฝ๋๋ฅผ ๊ฐ๋ฆฌํฌ ์ ์๋ค๋ ์ฌ์ค์ ๋ช ์ฌํ๋ผ.
hash(key) % array_length
์ ๊ฐ์ด ํด์ ์ฝ๋๋ฅผ ์ด์ฉํด ๋ฐฐ์ด์ ์ธ๋ฑ์ค๋ฅผ ๊ตฌํ๋ค.- ๋ฐฐ์ด์ ๊ฐ ์ธ๋ฑ์ค์๋ ํค์ ๊ฐ์ผ๋ก ์ด๋ฃจ์ด์ง ์ฐ๊ฒฐ๋ฆฌ์คํธ๊ฐ ์กด์ฌํ๋ค. ํค์ ๊ฐ์ ํด๋น ์ธ๋ฑ์ค์ ์ ์ฅํ๋ค. ์ถฉ๋์ ๋๋นํด์ ๋ฐ๋์ ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ฅผ ์ด์ฉํด์ผ ํ๋ค.
์ถฉ๋: ์๋ก ๋ค๋ฅธ ๋ ๊ฐ์ ํค๊ฐ ๊ฐ์ ํด์ ์ฝ๋๋ฅผ ๊ฐ๋ฆฌํค๊ฑฐ๋ ์๋ก ๋ค๋ฅธ ๋ ๊ฐ์ ํด์ ์ฝ๋๊ฐ ๊ฐ์ ์ธ๋ฑ์ค๋ฅผ ๊ฐ๋ฆฌํค๋ ๊ฒฝ์ฐ
-
ํ์ ์๊ฐ๋ณต์ก๋
- ์ถฉ๋์ด ์์ฃผ ๋ฐ์ํ๋ ์ต์ ์ ๊ฒฝ์ฐ์ ์ํ ์๊ฐ(worst case runtime) -> O(N) (N์ ํค์ ๊ฐ์)
- ์ผ๋ฐ์ ์ผ๋ก ํด์์ ๋ํด ์ด์ผ๊ธฐํ ๋๋ ์ถฉ๋์ ์ต์ํํ๋๋ก ์ ๊ตฌํ๋ ๊ฒฝ์ฐ๋ฅผ ๊ฐ์ -> O(1)
- ์ฐ๊ฒฐ๋ฆฌ์คํธ๊ฐ ์๋ ๊ท ํ ์ด์ง ํ์ ํธ๋ฆฌ(balanced binary search tree)๋ฅผ ์ด์ฉํด ๊ตฌํ-> O(logN)
- ํฌ๊ธฐ๊ฐ ํฐ ๋ฐฐ์ด์ ๋ฏธ๋ฆฌ ํ ๋นํด ๋์ง ์์๋ ๋๋ฏ๋ก ์ ์ฌ์ ์ผ๋ก ์ ์ ๊ณต๊ฐ์ ์ฌ์ฉ
- ํค์ ์งํฉ์ ํน์ ์์๋ก ์ฐจ๋ก๋๋ก ์ ๊ทผ ๊ฐ๋ฅ
- ๋ฐฐ์ด(array)
- Python, JavaScript ๋ฑ ํน์ ์ธ์ด: ํฌ๊ธฐ๋ฅผ ์๋์ผ๋ก ์กฐ์ -> "๋ฆฌ์คํธ(list)"
- Java: ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ ๊ณ ์ ๋์ด ๋ฐฐ์ด ์์ฑ ์ ํฌ๊ธฐ๋ฅผ ํจ๊ป ์ง์ ํด์ผ ํจ
- ArrayList
- ๋์ ๊ฐ๋ณ ํฌ๊ธฐ ๊ธฐ๋ฅ์ด ๋ด์ฌ๋์ด ์๋ ๋ฐฐ์ด๊ณผ ๋น์ทํ ์๋ฃ๊ตฌ์กฐ
- O(1)์ ์ ๊ทผ ์๊ฐ(access time)
- ๋ฐฐ์ด์ด ๊ฐ๋ ์ฐจ๋ ์๊ฐ, ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ๋ ๋ฐฐ๋ก ๋๋ฆฐ๋ค. ํฌ๊ธฐ๋ฅผ ๋ ๋ฐฐ ๋๋ฆฌ๋ ์๊ฐ์ O(N)์ด์ง๋ง, ์์ฃผ ๋ฐ์ํ๋ ์ผ์ด ์๋๋ผ์ ์ํ ์ ๋ ฅ ์๊ฐ(amortized insertion time)์ผ๋ก ๊ณ์ฐํ์ ๋ ์ฌ์ ํ O(1)์ด ๋๋ค.
- ํฌ๊ธฐ๊ฐ N์ธ ๋ฐฐ์ด์ ์๊ฐํด ๋ณด์. ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ K๋ก ๋๋ฆฌ๋ฉด ๊ทธ ์ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ K์ ์ ๋ฐ์ด์์ ๊ฒ์ด๋ฏ๋ก K/2๋งํผ์ ์์๋ฅผ ๋ณต์ฌํด์ผ ํ๋ค. ๋ฐ๋ผ์ N๊ฐ์ ์์๋ฅผ ์ฝ์ ํ๊ธฐ ์ํด์ ๋ณต์ฌํด์ผ ํ๋ ์์์ ์ด ๊ฐ์๋ N/2 + N/4 + N/8 + ... + 2 + 1, ์ฆ N๋ณด๋ค ์๋ค.
- ๋ฐ๋ผ์ N๊ฐ์ ์์๋ฅผ ์ฝ์ ํ ๋ ์์๋๋ ์์ ์ O(N)์ด ๋๋ค. ๋ฐฐ์ด์ ์ํฉ์ ๋ฐ๋ผ ์ต์ ์ ๊ฒฝ์ฐ์ O(N)์ด ์์๋๋ ์ฝ์ ์ฐ์ฐ๋ ์กด์ฌํ๊ธด ํ์ง๋ง ํ๊ท ์ ์ผ๋ก ๊ฐ ์ฝ์ ์ O(1)์ด ์์๋๋ค.
๋ฌธ์์ด์ ๋ฆฌ์คํธ๊ฐ ์ฃผ์ด์ก์ ๋ ์ด ๋ฌธ์์ด๋ค์ ํ๋๋ก ์ด์ด ๋ถ์ด๋ ค๊ณ ํ๋ค. ๋ชจ๋ ๋ฌธ์์ด์ ๊ธธ์ด(x)๊ฐ ๊ฐ์ n๊ฐ์ ๋ฌธ์์ด์ด ์ฃผ์ด์ก๋ค๊ณ ๊ฐ์ ํ์.
String joinWords(String[] words) {
String sentence = "";
for (String w : words) {
sentence = sentence + w;
}
return sentence;
}
๋ฌธ์์ด์ ์ด์ด๋ถ์ผ ๋๋ง๋ค ๋ ๊ฐ์ ๋ฌธ์์ด์ ์ฝ์ด ๋ค์ธ ๋ค ๋ฌธ์๋ฅผ ํ๋ํ๋ ์๋ก์ด ๋ฌธ์์ด์ ๋ณต์ฌํด์ผ ํ๋ค. ์ฒ์์๋ x๊ฐ, ๋ ๋ฒ์งธ๋ 2x๊ฐ, ์ธ ๋ฒ์งธ๋ 3x๊ฐ, n๋ฒ์งธ๋ nx๊ฐ์ ๋ฌธ์๋ฅผ ๋ณต์ฌํด์ผ ํ๋ค. ๋ฐ๋ผ์ ์ด ์ํ ์๊ฐ์ O(x + 2x + ... + nx), ์ฆ O(xn^2)์ด ๋๋ค.
StringBuilder๊ฐ ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด ์ค ์ ์๋ค. StringBuilder๋ ๋จ์ํ๊ฒ ๊ฐ๋ณ ํฌ๊ธฐ ๋ฐฐ์ด์ ์ด์ฉํด์ ํ์ํ ๊ฒฝ์ฐ์๋ง ๋ฌธ์์ด์ ๋ณต์ฌํ๊ฒ๋ ํด์ค๋ค.
String joinWords(String[] words) {
String sentence = new StringBuilder();
for (String w : words) {
sentence.append(w);
}
return sentence.toString();
}
๋ชจ๋ ํด์ํ ์ด๋ธ์์ ์ถฉ๋์ด ๋ฐ์ํ ์ ์๋ค. ์ด๋ฅผ ํด๊ฒฐํ๋ ๋ช ๊ฐ์ง ๋ฐฉ๋ฒ์ด ์กด์ฌํ๋ค.
- ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ฅผ ์ด์ฉํ ์ฒด์ด๋
- ํด์ํ ์ด๋ธ์ ๊ฐ ์์๊ฐ ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ก ๋์๋๋ ๋ฐฉ๋ฒ์ด๋ค.
- ๊ฐ์ฅ ํํ ๋ฐฉ๋ฒ์ด๋ค. ์ถฉ๋ ํ์๊ฐ ๊ฝค ์์ ๊ฒฝ์ฐ์๋ ์ด ๋ฐฉ๋ฒ์ผ๋ก ์ถฉ๋ถํ๋ค.
- ํด์ํ
์ด๋ธ์ N๊ฐ์ ์์๊ฐ ์์ ๋, ์ต์
์ ๊ฒฝ์ฐ ์์๋ฅผ ์ฐพ๋ ๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ: O(N)
- ๋ฐ์ดํฐ๊ฐ ์์ฃผ ์ด์ํ๊ฑฐ๋ ํด์ ํจ์ ์ฑ๋ฅ์ด ์์ฃผ ๋์ ๋(ํน์ ๋ ๋ค์ผ ๋) ๋ฐ์
- ์ด์ง ํ์ ํธ๋ฆฌ๋ฅผ ์ด์ฉํ ์ฒด์ด๋
- ์ต์ ์ ๊ฒฝ์ฐ: O(logN)
- ์ค์ ๋ก๋ ๋ฐ์ดํฐ๊ฐ ๊ทน๋จ์ ์ผ๋ก ๊ท ์ผํ๊ฒ ๋ถํฌ๋์ด ์์ง ์๋ ์ด์ ์ด ๋ฐฉ๋ฒ์ ์ฌ์ฉํ์ง ์๋๋ค.
- ์ ํ ํ์ฌ๋ฒ(linear probing)์ ์ด์ฉํ ๊ฐ๋ฐฉ ์ฃผ์๋ฒ(open addressing)
- ์ถฉ๋์ด ๋ฐ์ํ์ ๋(์ฃผ์ด์ง ์ธ๋ฑ์ค์ ์ด๋ฏธ ๋ฐ์ดํฐ๊ฐ ๋ค์ด์์ ๋), ๋น์ด ์๋ ์ธ๋ฑ์ค๋ฅผ ์ฐพ์ ๋๊น์ง ๋ค์ ์ธ๋ฑ์ค๋ก ์ด๋ํ๋ ๋ฐฉ๋ฒ์ด๋ค(
index + 5
์ฒ๋ผ ๊ณ ์ ๋ ๊ฑฐ๋ฆฌ๋งํผ ์์ง์ธ๋ค). - ์ถฉ๋ ํ์๊ฐ ์์ ๋, ์์ฃผ ๋น ๋ฅด๊ณ ๊ณต๊ฐ ์ ์ฝ์ ์ธ ๋ฐฉ๋ฒ์ด๋ค.
- ๋จ์
- ํด์ํ ์ด๋ธ์ ๋ด์ ์ ์๋ ์ ์ฒด ๋ฐ์ดํฐ๊ฐ ๋ฐฐ์ด์ ํฌ๊ธฐ์ ์ ํ๋๋ค. != ์ฒด์ด๋
- ํด๋ฌ์คํฐ๋ง(clustering)
- ์ถฉ๋์ด ๋ฐ์ํ์ ๋(์ฃผ์ด์ง ์ธ๋ฑ์ค์ ์ด๋ฏธ ๋ฐ์ดํฐ๊ฐ ๋ค์ด์์ ๋), ๋น์ด ์๋ ์ธ๋ฑ์ค๋ฅผ ์ฐพ์ ๋๊น์ง ๋ค์ ์ธ๋ฑ์ค๋ก ์ด๋ํ๋ ๋ฐฉ๋ฒ์ด๋ค(
- 2์ฐจ ํ์(quadratic probing)๊ณผ 2์ค ํด์(double hashing)
- ํ์ ๊ฑฐ๋ฆฌ๋ฅผ 2์ฐจ์์ผ๋ก ์ฆ๊ฐ์ํฌ ์๋ ์๋ค.
- ํน์ ํ์ฌ ๊ฑฐ๋ฆฌ๋ฅผ ๊ฒฐ์ ํ ๋ ๋ ๋ฒ์งธ ํด์ ํจ์๋ฅผ ์ฌ์ฉํ ์๋ ์๋ค.
- ์ค๋ณต์ด ์๋๊ฐ
- ์์ด ํ์ธ
- URLํ
- ํ๋ฌธ ์์ด
- ํ๋ ๋นผ๊ธฐ
- ๋ฌธ์์ด ์์ถ
- ํ๋ ฌ ํ์
- ()ํ๋ ฌ
- ๋ฌธ์์ด ํ์