ํด์๋ผ๋ ๋จ์ด๋ ์ํธํ ๊ด๋ จ ์ ๋ณด๋ฅผ ์์๋ณผ ๋ ์ฃผ๋ก ๋ค์๋ ๋จ์ด ๊ฐ๋ค.
์ค๋์ ํด์์ ๊ด๋ จํ ๊ฐ๋ ์ ๋ํด ์ด ์ ๋ฆฌ๋ฅผ ํด๋ด์ผ๊ฒ ๋ค.
Java์์๋ HashTable ๊ณผ HashMap ๋๋ค ์๋๋ฐ, ์ด ํฌ์คํ ์์๋ ๋์ ๊ตฌ๋ถ ์ง์ง๋ ์๊ณ , HashMap ๊ธฐ๋ฐ์ผ๋ก ํ ์ค๋ช ์์ ์๋ ค๋๋ฆฌ๋ ๋ฐ์ด๋ค.
๐ ํด์ ํ ์ด๋ธ ์๋ฃ๊ตฌ์กฐ๋ ๋ฌด์์ธ๊ฐ?
ํด์(Hash) ๋จ์ด ์์ฒด๋ ์ด๋ค ๊ฐ์ ์ผ์ ๊ธธ์ด๋ก ๋ณํํ๋ ๊ธฐ๋ฒ์ด๊ณ , ํด์ ํ ์ด๋ธ์ ๊ทธ ํด์ ๊ธฐ๋ฒ์ ์ ์ฉํ ์๋ฃ๊ตฌ์กฐ๋ผ๊ณ ํ ์ ์๋ค.
๊ฐ๋จํ๊ฒ key-value ๊ตฌ์กฐ๋ก ๋น ๋ฅด๊ฒ ๊ฒ์์ ํ ์ ์๋ค๋ ๊ฒ์ด ํน์ง์ด๋ค
๋์ฒด ํด์ ํ ์ด๋ธ์ด ๋ญ๊ธธ๋ ๋น ๋ฅด๊ฒ ๊ฒ์์ ํ ์ ์๋ ๊ฑธ๊น?
์ ์ฐ๋ฆฌ๊ฐ ์น๊ตฌ์ ์ ํ๋ฒํธ๋ฅผ ๊ฒ์ํ ์ ์๋ ์ฌ์ดํธ๋ฅผ ๋ง๋ค์๋ค๊ณ ์น์.
๊ฒ์์ฐฝ์ ์น๊ตฌ์ ์ด๋ฆ์ ์น๋ฉด ์ ํ๋ฒํธ๊ฐ ๋์ฌ ๊ฒ์ด๋ค.
์ด ๋ ์ด๋ฆ = Key, ์ ํ๋ฒํธ = Value ๊ฐ ๋๋ค.
๋์ฒด ์ด๊ฒ ๋ญ๋ฐ ๋น ๋ฅด๋ค๋ ๊ฑฐ์ง?
ํด์๊ฐ ์๋ค๋ ๊ฐ์ ํ์ ์ ํ๋ฒํธ๋ฅผ ๋ค์ ์ฐพ๋๋ค๊ณ ์๊ฐ์ ํด๋ณด์.
// ์ผ๋จ ์ ํ ๋ฒํธ ๋ฐฐ์ด์ด ์์ ๊ฒ์ด๋ค.
int phoneBook = new int[5];
// ์ฐพ๊ณ ์ ํ๋ ์ด๋ฆ
String name = "Kinzie";
/*
phonebook[name] ์ด๋ฐ ์์ผ๋ก๋ ์ ๋ ์ฐพ์ ์ ์๋ค.
*/
for (int i = 0; i < 5; i++) {
if (phonebookName[i] = name){
phoneBook[i];
}
}
์ ํ๋ฒํธ ๋ฐฐ์ด๊ณผ ์ด๋ฆ ๋ฐฐ์ด์ด ํ์ํ ๊ฒ์ด๊ณ ์ ํ๋ฒํธ๋ถ ๊ธธ์ด ๋งํผ ๋ฐ๋ณตํด์ ์ผ์นํ๋ ์ง ์๋์ง ํ์ธ ํด๊ฐ๋ฉฐ ์ฐพ์์ผํ๋ ์ ๋ฐ์ ์๋ค.
-> ์๊ฐ ๋ณต์ก๋๋ O(N) ์ด๋ผ์ ์ ํ๋ฒํธ๋ถ์ 1000๋ช 10000๋ช ์ด๋ฐ ์์ผ๋ก ๋์ด๊ฐ๋ฉด ๋ ๋๋ ค์ง๋ค.
์ด๋ฐ ์ฅ์ ๋ฟ๋ง์ด ์๋๋ผ ํด์ ํ ์ด๋ธ ๊ตฌ์กฐ๋ Key์ Value์ ๋ชจ๋ ๋ฐ์ดํฐ ํ์ ์ ๋ฃ์ ์ ์๊ธฐ ๋๋ฌธ์ ๊ต์ฅํ ํ์ฉ๋๊ฐ ๋์ ์ ๋ฐ์ ์๋ค.
๐ ํด์ ํ ์ด๋ธ์ ์ด๋ป๊ฒ ๋น ๋ฅผ ์ ์์ง?
๋ง์น int ๋ฐฐ์ด์์ int[0] ์ด๋ ๊ฒ ์ฐพ์ผ๋ฉด 0๋ฒ์งธ์ ํด๋นํ๋ value๋ฅผ ์ฐพ์ ์ ์๋ ๊ฒ์ฒ๋ผ,
ํด์ ํ ์ด๋ธ๋ phoneBook[name] ์ด๋ ๊ฒ ์ฐพ์ผ๋ฉด name์ ํด๋นํ๋ value๋ฅผ ์ฐพ์ ์ ์๊ฒ ๋๋ค.
์ด ๊ธ์ ๋ณด๋ ๋ชจ๋๊ฐ ์๋ฏ์ด ์ธ๋ฑ์ค๋ฅผ ์ด์ฉํด์ int ๋ฐฐ์ด์์ ๊ฐ์ ์ฐพ๋ ๊ฒ์ ์๊ฐ๋ณต์ก๋๊ฐ O(1)์ด๋ค.
๊ทธ๋ผ ๋์ฒด ํด์ ํ ์ด๋ธ ๊ตฌ์กฐ์์๋ ์ด๋ฐ ์ผ์ด ์ด๋ป๊ฒ ๊ฐ๋ฅํ๊ฒ ๋ ๊ฑธ๊น?
ํด์ ํ ์ด๋ธ์ Key ๊ฐ์ ํด์๊ฐ์ผ๋ก ๋ณํ -> ํด์๊ฐ์ ์ธ๋ฑ์ค๋ก ์ฌ์ฉ
์ด๋ฐ ๋ฉ์ปค๋์ฆ์ด๋ผ์ 1:1 ๋งค์นญ์ด ๋๊ณ , ๋น ๋ฅธ ๊ฒ์์ด ๊ฐ๋ฅํ๊ฒ ๋ ๊ฒ์ด๋ค.
1๏ธโฃ ์ ํํ ์ด๋ฆ์ด ํด์ "ํ ์ด๋ธ"์ผ๊น?
์ง๋ ์๋ฃ๊ตฌ์กฐ์ ์๊ณ ๋ฆฌ์ฆ ์ด์ ๋ฆฌ ๊ธ์์ ๊ณต๋ถํ๋ฏ์ด ์๋ฃ๊ตฌ์กฐ๋ ๋ฐ์ดํฐ๋ค์ ์งํฉ์ด๋ค.
๊ทผ๋ฐ ๋ฐ์ดํฐ ๊ณ์์ ํ ์ด๋ธ์ ์๊น์๋ ํก์ฌ ์์ ๊ณผ ๋น์ทํ๊ฒ ์๊ฒผ๋ค.
์ํค์์๋ ํ ์ด๋ธ(table)์ ์ธ๋ก์ค๊ณผ ๊ฐ๋ก์ค์ ๋ชจ๋ธ์ ์ด์ฉํ์ฌ ์ ๋ ฌ๋ ๋ฐ์ดํฐ ์งํฉ(๊ฐ)์ ๋ชจ์์ด๋ผ๊ณ ์ ์ํ๊ณ ์๋ค.
์ฌ์ค์ ํด์ ํ ์ด๋ธ์ ํ ์ด๋ธ์ ํํ๊ฐ ๋ง๊ธฐ ๋๋ฌธ์ด๋ค.
1. Key ๊ฐ์ด ํด์ ํจ์๋ฅผ ํตํด ํด์ ๊ฐ์ผ๋ก ๋ณํ
2. ๋ณํ๋ ํด์ ๊ฐ์ด ํด์ ํ ์ด๋ธ์์ ์ธ๋ฑ์ค๋ก ์ฐ์
3. ์ด ์ธ๋ฑ์ค์ ํ row๋ฅผ Bucket์ด๋ผ๊ณ ํ๊ณ , ํ Bucket ์์๋ ์ฌ๋ฌ Slot์ด ์์ ์ ์๋ค.
Bucket์ ํฌ๊ธฐ๊ฐ 4, ์ฌ๋กฏ์ ํฌ๊ธฐ๊ฐ 3์ธ ํด์ ํ ์ด๋ธ์ ์ด๋ฐ์์ผ๋ก 4*3 ํํ๊ฐ ๋ ๊ฒ์ด๋ค.
์ด ๋์ ํด์ ํ ์ด๋ธ์ ์ ์ฒด ์ ์ฅ ๊ฐ๋ฅ ๊ณต๊ฐ์ 12์นธ์ด ๋ ๊ฒ์ด๋ค.
2๏ธโฃ ํด์ ์ถฉ๋์ ์ ์๊ธฐ๋ ๊ฑธ๊น?
์์์ ํค ๊ฐ์ ํด์ ํจ์๋ฅผ ํตํด ํด์ ๊ฐ์ผ๋ก ๋ณํํด์ ํด์ ํ ์ด๋ธ์ ์ธ๋ฑ์ค๋ก์ ์ฐ์ธ๋ค๊ณ ํ๋ค.
๊ทธ๋ฆผ์ผ๋ก ํ๋ฒ ์ ๋ฆฌํด๋ณด์.
์ฌ๊ธฐ ์์ ์์ ์ฃผ์ด์ง ํค๋ค์ ์๋ก ๊ฐ๊ฐ ๋ค๋ฅธ ๊ฐ์ด๊ณ , ์๋ก ๋ค๋ฅธ ํด์ ์ฝ๋๋ฅผ ๊ฐ๊ณ ์๋ค.
๊ทผ๋ฐ ํด์ ํจ์๋ฅผ ๊ฑฐ์ณ์ ๋์จ ํด์ ๊ฐ (= ํด์ ํ ์ด๋ธ์ ์ธ๋ฑ์ค )์ ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ๋์๋ค.
์ด๊ฒ์ด ๋ฐ๋ก ํด์ ์ถฉ๋ ์ํฉ์ด๋ค.
์ฆ, ์๋ก ๋ค๋ฅธ ํค ๊ฐ์ด ํด์ ํจ์์ ์ํด ๊ฐ์ ํด์ ๊ฐ(ํด์ ์ฃผ์)์ ๊ฐ๊ฒ ๋์ด์ ์๊ธฐ๋ ๋ฌธ์ ์ด๋ค.
ํด์ ์ถฉ๋์ ํด์ ํจ์์ ์ํด์๋ ๋ฐ์๋ ์ ์์ง๋ง, ํด์ ํ ์ด๋ธ์ Bucket ์ฌ์ด์ฆ๊ฐ ์ ํํด์ ์๊ธธ ์๋ ์๋ค.
์ํฉ์ด์ผ ์ด์ฐ๋์๋ , ์ ๋ฐ ๊ฒฐ๊ณผ๊ฐ ๋์ค๋ฉด ๊ทธ๊ฒ์ด ๋ฐ๋ก ํด์ ์ถฉ๋์ด๋ค.
ํด์ ์ถฉ๋์ด ๋ฐ์ํ๊ณ , ๋ฒํท ์์ ๋ค๋ฅธ ์ฌ๋กฏ์ ์ ์ฅ๋๊ณ , ๊ทธ ์ฌ๋กฏ๋ง์ ๋ค ์ฐจ๋ฒ๋ ธ๋๋ฐ ๋ ๋ฐ์ดํฐ๊ฐ ๋ค์ด์์ผํ๋ ๊ฒฝ์ฐ๋ ์ค๋ฒํ๋ก์ฐ ์ํฉ์ด๋ผ๊ณ ํ๋ค.
๊ทธ๋ ๋ค๋ฉด ํด์ ์ถฉ๋์ด ์๋๊ฒ ํด์ ํจ์๋ฅผ ์ค์ ํ๋ฉด ๋ ๊ฒ ์๋๋ ํ ์ ์๋ค.
์๋ก ๋ค๋ฅธ ๊ฐ์ฒด X์ Y๊ฐ ์๋ค๊ณ ํ์๋, X.hashCode() != Y.hashCode() ๋ฉด ์ด๋ ์ฌ์ฉํ๋ ํด์ ํจ์๋ฅผ ์์ ํ ํด์ ํจ์๋ผ๊ณ ํ๋ค.
๊ทผ๋ฐ ์๊ฐํด๋ณด๋ฉด, Integer, Long, Double ์ฒ๋ผ Number ๊ฐ์ฒด์ผ ๊ทธ ๊ณ ์ ์ ๊ฐ ์์ฒด๋ฅผ ํด์ ๊ฐ์ผ๋ก ๊ฐ์ง ์ ์๊ฒ ์ง๋ง, String์ด๋ POJO (Plain Old Java Object )๋ฑ์ ๊ทธ๊ฒ ๋ถ๊ฐ๋ฅํ ๊ฒ์ด๋ค. => ํด์๊ฐ์ด ๊ฒน์น ์ ๋ฐ์ ์์
์ด๋ค ์์ ํ ํด์ ํจ์๊ฐ ์๋ค๊ณ ํ๋๋ผ๋ HashMap์์ ์ฌ์ฉํ๊ธฐ์ ํ๋ค๋ค.
HashMap ์์๋ ๊ฐ ๊ฐ์ฒด์ hashCode() ๋ฉ์๋๊ฐ ๋ฐํํ๋ ๊ฐ์ ์ฌ์ฉํ๋๋ฐ, ๊ฒฐ๊ณผ ์๋ฃํ์ ์ต๋ intํ์ ์ ์์ด๋ค.
public final int hashCode() {
if (this.bits() >= 32) {
return this.asInt();
} else {
byte[] bytes = this.getBytesInternal();
int val = bytes[0] & 255;
for(int i = 1; i < bytes.length; ++i) {
val |= (bytes[i] & 255) << i * 8;
}
return val;
}
}
32๋นํธ ์๋ฃํ์ผ๋ก๋ ์์ ํ ํด์ ํจ์๋ฅผ ๋ง๋ค ์ ์๋ค.
์ค์ ๋ก ์์ฑ ๊ฐ๋ฅํ ๊ฐ์ฒด์ ์๋ 2^32๋ณด๋จ ๋ง์ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ด๋ค. ๋ฐ๋ผ์ ์ด์ฐจํผ ๋ชป ๋ง๋ค๊ณ ์ถฉ๋ ๋ ๊ฑฐ ์ค์ ๋ด๋ถ์ ์ผ๋ก๋ ๋ฉ๋ชจ๋ฆฌ ์ ์ฝ์ ์ํด % ์ฐ์ฐ์๋ฅผ ํ์ฉํด์ ๋ฒํท์ ์๋ฅผ ์ค์ฌ๋ฒ๋ฆฌ๋ ๋ฑ์ ํ์๊ฐ ์ด๋ฃจ์ด์ง๋ค.
๊ทธ๋ผ ์ด์ ์๋ก ๋ค๋ฅธ ๊ฐ์ฒด๊ฐ ๊ฒน์น ํ๋ฅ ์ด ๋ ์ฌ๋ผ๊ฐ๊ฒ ๋๋ค. ๋ฐ๋ผ์ ํด์ ์ถฉ๋์ ํผํ ์ ์๋ค.
์ข์ ํด์ ํจ์๋?
ํด์ ํจ์๋ Key๋ฅผ ํด์ ํ ์ด๋ธ์ ๋ฒํท ์ฃผ์(=index)๋ก ๋ณํ(Hashing)ํ๋ ์ญํ ์ ํ๋ค. ๋ฒํท์ ์ฌ์ด์ฆ๋ ์ ํํ๊ธฐ ๋๋ฌธ์ Key๊ฐ ์ต๋ํ ํ ์ฃผ์๋ก ๋ชฐ๋ฆฌ์ง ์๋๋ก ํด์ผํ๋ค. ์ฆ, ๋ฒํท์ด 8๊ฐ๊ฐ ์๋ค๋ฉด ๊ฐ ๋ฒํท์ด Key์ ๋์๋ ํ๋ฅ ์ด ๋ชจ๋ ๋์ผํ๊ฒ 1/8 ์ฉ ์ฐจ์งํ๋ ๊ฒ์ด ์ข์ ๊ฒ์ด๋ค. ์ด๋ฐ ํจ์๋ฅผ ๊ท ๋ฑ ํด์ ํจ์(uniform hash function)๋ผ๊ณ ํ๋ค.
๋ํ์ ํด์ ํจ์ ๊ธฐ๋ฒ์๋ ์ค๊ฐ์ ๊ณฑ๋ฒ(mid-squre method), ๋๋์ ๋ฒ(division method), ์ซ์๋ถ์๋ฒ(digit analysis method), ์ ์ง๋ฒ(folding method) ๋ฑ์ด ์๋ค.
ํด์ ์ถฉ๋ ํด๊ฒฐ ๋ฐฉ์ 1. Separate Chaining ( ๊ฐ๋ณ ์ฒด์ด๋ )
์์์ ์ด์ง ๋ง๋ดค๋ slot์ ๊ฐ๋ ์ผ๋ก LinkedList๋ฅผ ํ์ฉํด์ ํด๊ฒฐํ๋ ๊ฒ์ด๋ค.
- ํด์ ์ถฉ๋์ด ๋ฐ์ํ๋ฉด LinkedList๋ก ๋ ธ๋๋ฅผ ์ถ๊ฐํ์ฌ ์ฐ๊ฒฐํ๊ธฐ ๋๋ฌธ์ ํฌ๊ธฐ ์ ํ์ ์์ด์ ์์ ๋กญ๋ค.
- ๋ฐ์ดํฐ๋ฅผ ๊ฒ์ํ ๋๋ Key์ ๋ํ index๋ฅผ ๊ตฌํ๊ณ , index๊ฐ ๊ฐ๋ฆฌํค๊ณ ์๋ LinkedList๋ฅผ ์ ํ ๊ฒ์ํด์, ํด๋น Key์ ๋ํ ๋ฐ์ดํฐ๊ฐ ์๋์ง ํ์ธ ํ์ ๋ฆฌํดํ๊ฒ ๋๋ค.
- ์ญ์ ๋ํ ๋น์ทํ๋ค. ์ ํ ๊ฒ์ํด์ ํด๋น ๋ ธ๋๋ฅผ ์ญ์ ์ฒ๋ฆฌํ๋ฉด ๋๋ค.
- ๋์ผํ ํด์ ๊ฐ์ ๊ฐ์ง ํญ๋ชฉ๋ค์ ํ๋์ ๋ฆฌ์คํธ๋ก ๊ด๋ฆฌ๋๊ธฐ ๋๋ฌธ์, ๋ค๋ฅธ ์ฌ๋กฏ์ ์ํฅ์ ์ฃผ์ง ์๋๋ค. ์ด๋ก ์ธํด ํด๋ฌ์คํฐ๋ง(์ธ์ ํ ์ฌ๋กฏ๋ค์ด ๊ฐ๋ ์ฐจ๊ฒ ๋๋ ํ์)์ด ๋ฐ์ํ์ง ์๋๋ค.
- ํด์ ํจ์์ ๋ํด ๋ ๋ฆฝ์ฑ์ด ์๋ค. ํด์ ํจ์๊ฐ ๋์ผํ ํด์ ๊ฐ์ ๋ฐํํ๋ ๊ฒฝ์ฐ์๋ง ์ถฉ๋์ด ๋ฐ์ํ๋ฉฐ, ์ด ์ถฉ๋์ ๋จ์ํ ํด๋น ์ฌ๋กฏ์ ๋ฆฌ์คํธ์ ์ถ๊ฐํ๋ ๋ฐฉ์์ผ๋ก ์ฒ๋ฆฌ๋๋ค. ๋ฐ๋ผ์, ํด์ ํจ์์ ๋ถํฌ๊ฐ ์ข์ง ์๋๋ผ๋(์ฆ, ํด์ ๊ฐ์ด ๊ณ ๋ฅด๊ฒ ๋ถํฌ๋์ง ์๋๋ผ๋) ํด๋ฌ์คํฐ๋ง ๋ฌธ์ ๋ฅผ ์ผ์ผํค์ง ์๋๋ค.
Java 8 ๋ถํฐ๋ ํ๋์ ํด์ ๋ฒํท์ 8๊ฐ์ ํค-์์ด ๋ชจ์ด๋ฉด LinkedList๋ฅผ Tree๋ก ๋ณ๊ฒฝํ๋ค. ํด์ ์ถฉ๋์ด ๋ง์ด ์ผ์ด๋์ ๋ชจ๋ ํค๊ฐ ๊ฐ์ ํด์๊ฐ์ ๊ฐ๊ฒ๋๋ฉด O(n)์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ง๊ฒ ๋๊ธฐ ๋๋ฌธ์ด๋ค. ๋ง์ฝ์ ํด๋น ๋ฒํท์ ์๋ ๋ฐ์ดํฐ๋ฅผ ์ญ์ ํ์ฌ ๊ฐ์๊ฐ 6๊ฐ๊ฐ ๋๋ฉด ๋ค์ ๋งํฌ๋ ๋ฆฌ์คํธ๋ก ๋ณ๊ฒฝํ๋ค. 2๊ฐ์ ์ฐจ์ด๋ฅผ ๋์ด 1๊ฐ์ ์ด๋ค ํค-๊ฐ ์์ด ๋ฐ๋ณต์ ์ผ๋ก ์ฝ์ /์ญ์ ๊ฐ ์ผ์ด๋ฌ์ ๋ ํธ๋ฆฌ-๋งํฌ๋๋ฆฌ์คํธ ๋ณํ์ผ๋ก ์ธํ ์ฑ๋ฅ์ ํ๋ฅผ ์๋ฐฉํ๋ค.
๋ฐ๋ผ์ ๋ด๋ถ ์ฝ๋์์๋ TreeNode๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํด Java 7์์ ์ฒ๋ผ Entry ํด๋์ค๊ฐ ์๋๋ผ Nodeํด๋์ค๋ฅผ ์ฌ์ฉํ๋ค.
์ด ๋ ์ฌ์ฉ๋๋ ํธ๋ฆฌ๋ Red-Black Tree์ธ๋ฐ, TreeMap๊ณผ ๊ตฌํ์ด ๊ฑฐ์ ๊ฐ๋ค. ์ต์ ์ ๊ฒฝ์ฐ์๋ ํ์, ์ฝ์ , ์ญ์ ๊ฐ O(log n) ์๊ฐ์ ์ํ๋๋ค๋ ํน์ง์ด ์๋ค.
ํด์ ์ถฉ๋ ํด๊ฒฐ ๋ฐฉ์ 2. Open Addressing ( ๊ฐ๋ฐฉ ์ฃผ์๋ฒ )
๊ฐ๋ฐฉ ์ฃผ์๋ฒ์์๋ ๋ชจ๋ ํค-๊ฐ ์์ ๋์ผํ ๋ฐฐ์ด์ ์ ์ฅํ๋ค. ์ถฉ๋์ด ๋ฐ์ํ์ ๋ ์ถ๊ฐ์ ์ธ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ์ง ์๊ณ , ๋์ผํ ๋ฐฐ์ด ๋ด์์ ๋น ์ฌ๋กฏ์ ์ฐพ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ค. -> ์ฌ๋กฏ์ ํฌ๊ธฐ๊ฐ 1์ด๋ผ๋ ์๋ฆฌ๋ค.
์ถฉ๋์ด ๋ฐ์ํ์ ๋ ๋ค๋ฅธ ์ฌ๋กฏ์ ํ์ฌ(Probing)ํ์ฌ ๋น ์ฌ๋กฏ์ ์ฐพ๋ ๋ฐฉ์์ผ๋ก ์ถฉ๋์ ํด๊ฒฐํ๋ค.
๋ฐ์ดํฐ๋ฅผ ์ญ์ ํ๋ฉด ์ญ์ ๋ ๊ณต๊ฐ์ Dummy Space๋ก ํ์ฉ๋๋ค.
Dummy Node๋ ์ค์ ๊ฐ์ ๊ฐ์ง์ง๋ ์์ง๋ง, ๊ฒ์ํ ๋ ๋ค์ ์์น(์ธ๋ฑ์ค)๊น์ง ์ฐ๊ฒฐํด์ฃผ๋ ์ญํ ์ ํ๋ค.
ํ์ง๋ง ์ญ์ ๊ฐ ๋น๋ฒํ ์ผ์ด๋์ Dummy Node ์๊ฐ ๋ง์์ง ์ํ์์ ๊ฒ์ํ ๊ฒฝ์ฐ์ ๋ง์ ๋ฒํท(Bucket)์ ์ฐ์์ ์ผ๋ก ๊ฒ์ํด์ผํ๋ค.
๋ฐ๋ผ์, ์ด Dummy Node์ ๊ฐ์๊ฐ ์ผ์ ์ ์ด์์ด ๋์์ ๊ฒฝ์ฐ์ ์ฃผ๊ธฐ์ ์ผ๋ก ์๋ก์ด ๋ฐฐ์ด์ ๋ง๋ค์ด๊ณ ์ฌํด์(Rehash)๋ฅผ ํด์ค์ผ ์ฑ๋ฅ์ ์ ์งํ ์ ์๋ค.
ํ์ ๋ฐฉ๋ฒ์ ๋ฐ๋ผ ๋ค์ํ ๊ฐ๋ฐฉ ์ฃผ์๋ฒ์ด ์กด์ฌํ๋ค. ๋ํ์ ์ธ 3๊ฐ์ง๋ฅผ ์์๋ณด๋๋ก ํ๊ฒ ๋ค.
1๏ธโฃ ์ ํ ํ์ฌ (Linear Probing)
๊ฐ์ฅ ๊ฐ๋จํ ๋ฐฉ์์ด๋ค.
์ถฉ๋์ด ์ผ์ด๋ ๊ทธ ์์น์์ ์ผ์ ํ ๊ฐ๊ฒฉ(ex ๊ณ ์ ํญ 1)์ผ๋ก ๋ค์ ์ฌ๋กฏ์ ์์ฐจ์ ์ผ๋ก ํ์ํ์ฌ ๋น ์์ญ์ ํค๋ฅผ ์ ์ฅํ๋ ๋ฐฉ์์ด๋ค.
์ผ๋ฐ์ ์ผ๋ก ์ ํํ๋ก ํ์ํ๋ฉฐ, ์ฌ๊ธฐ์ h(k)๋ ํค k์ ๋ํ ํด์ ๊ฐ, i๋ ํ์ฌ ๋จ๊ณ, m์ ํด์ ํ ์ด๋ธ์ ํฌ๊ธฐ์ด๋ค.
Primary Clustering(1์ฐจ ํด๋ฌ์คํฐ๋ง: ํน์ ์์ญ์ ์์๊ฐ ๋ชฐ๋ฆฌ๋ ํ์) ์ ์ทจ์ฝํ๋ค.
- ์ ํ ํ์ฌ๋ ์ถฉ๋์ด ๋ฐ์ํ ์์น๋ก๋ถํฐ ์ฐ์๋ ๋น ์ฌ๋กฏ์ ์ฐพ๊ธฐ ๋๋ฌธ์, ํด์ ํ ์ด๋ธ์ ๋น ๊ณต๊ฐ์ด ์ฐ์์ ์ผ๋ก ์กด์ฌํ ๋๊น์ง ์ด๋ํ๋ค.
- ์ด๋ก ์ธํด ์ฌ๋ฌ ๊ฐ์ ์ถฉ๋์ด ๊ฐ์ ๋ฒ์ ๋ด์์ ๋ฐ์ํ๋ฉด, ์ฐ์๋ ์ฌ๋กฏ๋ค์ด ์ฑ์์ง๊ฒ ๋์ด ํด๋ฌ์คํฐ(์ฐ์๋ ์ฌ์ฉ ์ฌ๋กฏ)๊ฐ ํ์ฑ๋๋ค.
- ์๋ก์ด ํค๊ฐ ์ฝ์ ๋ ๋ ๊ธฐ์กด ํด๋ฌ์คํฐ์ ์ถฉ๋ํ๋ฉด, ํด๋น ํค๋ ํด๋ฌ์คํฐ์ ๋์ ์ฝ์ ๋๋ค.
- ๊ฒฐ๊ณผ์ ์ผ๋ก ํด๋ฌ์คํฐ๊ฐ ์ ์ ๋ ๊ธธ์ด์ง๋ค. => ์ถฉ๋ ๊ฐ๋ฅ์ฑ๋ ๋์์ง๋ค. ์ต์ ์ ๊ฒฝ์ฐ ํด์ ํ ์ด๋ธ(Hash Table) ์ ์ฒด๋ฅผ ๊ฒ์ํด์ผ ํ๋ ์ํฉ์ด ๋ฐ์ํ ์ ์๋ค.
2๏ธโฃ ์ด์ฐจ ํ์ฌ (Quadratic Probing)
์ ํ ๊ฒ์๋ฒ(Linear Probing)์์ ๋ฐ์ํ๋ 1์ฐจ ํด๋ฌ์คํฐ๋ง(Primary Clustering) ๋ฌธ์ ๋ฅผ ์ ๊ฑฐํ๋ ๋ฐฉ๋ฒ์ด๋ค.
์ถฉ๋์ด ๋ฐ์ํ๋ฉด ์ ๊ณฑ๋งํผ ๊ฑด๋๋ด ๋ฒ์ผ์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ ํ๋ ๋ฐฉ์์ด๋ค. ์๋ฅผ ๋ค์ด ์ฒ์ ์ถฉ๋์ด ๋ฐ์ํ ๊ฒฝ์ฐ์๋ 1๋งํผ ์ด๋ํ๊ณ ๊ทธ ๋ค์ ๊ณ์ ์ถฉ๋์ด ๋ฐ์ํ๋ฉด 2², 3² ์นธ์ฉ ์ฎ๊ธฐ๋ ๋ฐฉ์์ด๋ค.
Secondary Clustering(2์ฐจ ํด๋ฌ์คํฐ๋ง: ์ฌ๋ฌ ๊ฐ์ ์์๊ฐ ๋์ผํ ์ด๊ธฐ ํด์ ํจ์๊ฐ์ ๊ฐ๋ ํ์ )์ ์ทจ์ฝํ๋ค
- ์ผ์ ํ ํ์ฌ ๊ฑฐ๋ฆฌ๊ฐ ์ ๊ณฑ์๋ก ์ฆ๊ฐํ๋ค๋ณด๋, ํน์ ํ ์ถฉ๋ ํจํด์ด ๋ฐ์ํ ์ ์๋ค.
- ์๋ฅผ ๋ค์ด, ํน์ ์ธ๋ฑ์ค์์ ์ถฉ๋์ด ๋ฐ์ํ๋ฉด ๊ทธ ๋ค์ ํ์ฌ ์์น๋ ๋น์ทํ ๊ฑฐ๋ฆฌ์ ์์นํ ๊ฐ๋ฅ์ฑ์ด ๋์์ง๋ค.
- ์ด๋ ์ฐ์๋ ์ฌ๋กฏ์ ์ฌ๋ฌ ํค๊ฐ ๋ชจ์ด๊ฒ ๋์ด ํด๋ฌ์คํฐ๋ฅผ ํ์ฑํ๋ค.
3๏ธโฃ ์ด์ค ํด์ฑ (Double Hashing)
ํ๋์ ํด์ ํจ์(Hash Function)์์ ์ถฉ๋์ด ๋ฐ์ํ๋ฉด 2์ฐจ ํด์ ํจ์๋ฅผ ์ด์ฉํด ๊ฒ์ ์ด๋ ๊ฑฐ๋ฆฌ๋ฅผ ์ป๋ ๋ฐฉ๋ฒ์ด๋ค.
๋ ๊ฐ์ ์๋ก ๋ค๋ฅธ ํด์ ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ์ถฉ๋์ ํด๊ฒฐํ๋ค.
ํด๋ฌ์คํฐ๋ง ๋ฌธ์ ๋ฅผ ์ต์ํ ํ ์ ์๋ค.
๊ฐ์ฅ ๋ง์ ์ฐ์ฐ๋์ ์๊ตฌํ๋ค.
Java์์๋ ํด์ํ ์ด๋ธ ์๋ฃ๊ตฌ์กฐ์ ๋ํด ๊ฐ๋ณ ์ฒด์ด๋ ๋ฐฉ์์ ์ฑํํ๊ณ ์์ง๋ง ์คํ ์ด๋๋ ์ฑ ๋ฐฉ์์ ์ทจํ๋ ์ธ์ด๋ ์๋ค.
๐ ๋ก๋ ํฉํฐ์ ๋ณด์กฐ ํด์ ํจ์
๋ก๋ ํฉํฐ์ ์ฑ๋ฅ, ๋ฆฌ์ฌ์ด์ง ์ ๋ฆฌ ํ๊ธฐ ๋จ์
๋ก๋ ํฉํฐ์ ๋ฆฌ์ฌ์ด์ง
๋ก๋ ํฉํฐ(Load Factor)๊ฐ ๋ญ๊น?
ํญ๊ณต ์ฉ์ด์์ ๊ธฐ์ธํ ๊ฒ์ผ๋ก, ์๋๋ ์ค๋๋๋น ๋นํ์ฒด๊ฐ ๊ฒฌ๋ ์ ์๋ ์ต๋ ํ์ค์ ๋งํ๋ค.
์ด์ฒ๋ผ ์ปดํจํฐ ๊ณตํ์์๋ ์ฉ๋ ๋๋น ๋ฐ์ดํฐ๊ฐ ์ด๋ ์ ๋ ์ฐผ์ ๋ ์ฌ์ด์ฆ๋ฅผ ๋๋ ค์ฃผ๋ ์๊ณ์ ์ ๋ปํ๋ค.
๋ฐ๋ผ์ ํด์ ํ ์ด๋ธ์๋ ๋น์ฐํ ๋ก๋ ํฉํฐ๊ฐ ์กด์ฌ ํ๋๋ฐ,
๐ Ref
https://en.wikipedia.org/wiki/Hash_table
https://d2.naver.com/helloworld/831311