ํด์ ์๋ฃ ๊ตฌ์กฐ(Hash Data Structure)๋ฅผ ์ฌ์ฉํ ๋ ํผํ ์ ์๋ ๋ฌธ์ ์ค ํ๋๊ฐ ํด์ ์ถฉ๋(Hash Collision)์
๋๋ค. ํ์๋ค๊ณผ ์ค์ ์ ๊ฐ์ด ์ปคํผ ๋ง์๋ฉด์ ํด์ ์ถฉ๋ ๊ด๋ จํด์ ์ด์ผ๊ธฐ ํ๋๋ฐ ๋ด๊ฐ ์ ๋ง ์๋๊ฑธ๊น..? ํ๋ ๋ง์์ด ๋ค์ด ์ด๋ฒ ๊ธฐํ์ ํด์ ์ถฉ๋์ ๊ฐ๋
๊ณผ ์ด๋ฅผ ํด๊ฒฐํ๋ ๋ค์ํ ๊ธฐ๋ฒ๋ค์ ์ ๋ฆฌํด๋ณด๊ฒ ์ต๋๋ค.
ํด์ ์ถฉ๋์ ์๋ก ๋ค๋ฅธ ํค๊ฐ ๋์ผํ ํด์ ๊ฐ์ ๊ฐ๋ ํ์์ ์๋ฏธํฉ๋๋ค. ํด์ ํจ์๋ ๋ฌดํํ ์ ๋ ฅ ๊ณต๊ฐ์ ์ ํํ ์ถ๋ ฅ ๊ณต๊ฐ(ํด์ ํ ์ด๋ธ์ ํฌ๊ธฐ)์ผ๋ก ๋งคํํ๊ธฐ ๋๋ฌธ์, ์ถฉ๋์ ๋ถ๊ฐํผํฉ๋๋ค.
h(x) = x % 5 ๋ฅผ ์ฌ์ฉํ๋ค๊ณ ๊ฐ์ ํ ๋:h(10) = 10 % 5 = 0h(15) = 15 % 5 = 0h(20) = 20 % 5 = 010, 15, 20)์ด ๊ฐ์ ํด์ ๊ฐ(0)์ ๊ฐ์ง๋ฏ๋ก ํด์ ์ถฉ๋์ด ๋ฐ์ํฉ๋๋ค.ํด์ ์ถฉ๋์ ํด๊ฒฐํ์ง ์์ผ๋ฉด, ํด์ ํ ์ด๋ธ์์ ๋ฐ์ดํฐ๋ฅผ ์ฌ๋ฐ๋ฅด๊ฒ ์ ์ฅํ๊ฑฐ๋ ๊ฒ์ํ๋ ๋ฐ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค.
ํด์ ์ถฉ๋์ ํด๊ฒฐํ๊ธฐ ์ํด ์ผ๋ฐ์ ์ผ๋ก ๊ฐ๋ฐฉ ์ฃผ์๋ฒ(Open Addressing)๊ณผ ๋ถ๋ฆฌ ์ฐ๊ฒฐ๋ฒ(Separate Chaining)์ ์ฌ์ฉํฉ๋๋ค.
๊ฐ๋ฐฉ ์ฃผ์๋ฒ์ ์ถฉ๋์ด ๋ฐ์ํ์ ๋, ๋์ผํ ํด์ ํ ์ด๋ธ ๋ด์์ ๋ค๋ฅธ ๋น ๋ฒํท์ ์ฐพ์ ์ ์ฅํ๋ ๋ฐฉ๋ฒ์ ๋๋ค. ์ด ๋ฐฉ์์๋ ๋ค์๊ณผ ๊ฐ์ ๊ธฐ๋ฒ๋ค์ด ์์ต๋๋ค:
์ถฉ๋์ด ๋ฐ์ํ๋ฉด ํ ์นธ์ฉ ์ด๋ํ๋ฉฐ ๋น ๊ณต๊ฐ์ ์ฐพ๋ ๋ฐฉ๋ฒ์ ๋๋ค.
์์ ์ฝ๋ (Java):
public class LinearProbingHashTable {
private static final int SIZE = 10;
private Integer[] table = new Integer[SIZE];
public void insert(int key) {
int index = key % SIZE;
while (table[index] != null) {
index = (index + 1) % SIZE; // ๋ค์ ์ธ๋ฑ์ค๋ก ์ด๋
}
table[index] = key;
}
}
โ๏ธ ์ฅ์ : ๊ตฌํ์ด ๊ฐ๋จํ๊ณ ๋ฉ๋ชจ๋ฆฌ ํจ์จ์
โ ๏ธ ๋จ์ : ํด๋ฌ์คํฐ๋ง(Clustering) ๋ฌธ์ ๊ฐ ๋ฐ์ํ์ฌ ์ฐ์๋ ๋น ๊ณต๊ฐ์ด ์ค์ด๋ค ์ ์์
์ถฉ๋์ด ๋ฐ์ํ๋ฉด ์ด๋ ๊ฑฐ๋ฆฌ๋ฅผ ์ ๊ณฑ์๋ก ์ฆ๊ฐ์ํค๋ฉฐ ๋น ๊ณต๊ฐ์ ์ฐพ๋ ๋ฐฉ๋ฒ์ ๋๋ค.
ํ์ฌ ๋ฐฉ์ ์์:
index + 1^2index + 2^2index + 3^2โ๏ธ ์ฅ์ : ํด๋ฌ์คํฐ๋ง ๋ฌธ์ ๋ฅผ ์ํํ ์ ์์
โ ๏ธ ๋จ์ : ํ
์ด๋ธ ํฌ๊ธฐ๊ฐ ์์(prime number)๊ฐ ์๋๋ฉด ์ถฉ๋์ด ํด๊ฒฐ๋์ง ์์ ์๋ ์์
์ถฉ๋์ด ๋ฐ์ํ๋ฉด ๋ณด์กฐ ํด์ ํจ์(Secondary Hash Function)๋ฅผ ์ฌ์ฉํ์ฌ ์๋ก์ด ํด์ ๊ฐ์ ๊ณ์ฐํด ๋น ๊ณต๊ฐ์ ์ฐพ์ต๋๋ค.
ํด์ ํจ์ ์์:
int h1(int key) { return key % SIZE; }
int h2(int key) { return 7 - (key % 7); }
(h1(key) + i * h2(key)) % SIZEโ๏ธ ์ฅ์ : ํด๋ฌ์คํฐ๋ง ๋ฌธ์ ๋ฅผ ์์ ํ ํด๊ฒฐ ๊ฐ๋ฅ
โ ๏ธ ๋จ์ : ์ฐ์ฐ๋์ด ๋ง์์ง ์ ์์
๋ถ๋ฆฌ ์ฐ๊ฒฐ๋ฒ์ ๊ฐ ๋ฒํท์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ(Linked List)๋ก ๊ด๋ฆฌํ์ฌ, ์ถฉ๋์ด ๋ฐ์ํ๋ฉด ํด๋น ๋ฒํท์ ๋ฆฌ์คํธ์ ์๋ก์ด ์์๋ฅผ ์ถ๊ฐํ๋ ๋ฐฉ์์ ๋๋ค.
์์ ์ฝ๋ (Java):
import java.util.LinkedList;
public class SeparateChainingHashTable {
private static final int SIZE = 10;
private LinkedList<Integer>[] table = new LinkedList[SIZE];
public SeparateChainingHashTable() {
for (int i = 0; i < SIZE; i++) {
table[i] = new LinkedList<>();
}
}
public void insert(int key) {
int index = key % SIZE;
table[index].add(key);
}
}
โ๏ธ ์ฅ์ : ํด์ ํ
์ด๋ธ์ ํฌ๊ธฐ์ ์ ํ์ ๋ฐ์ง ์์ผ๋ฉฐ, ์ถฉ๋ ๋ฐ์ ์ ํ์ ์๊ฐ์ด ์ผ์
โ ๏ธ ๋จ์ : ๊ฐ ๋ฒํท์ด ๋ฆฌ์คํธ๋ฅผ ์ ์งํด์ผ ํ๋ฏ๋ก ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ด ์ฆ๊ฐ
| ํด๊ฒฐ ๋ฐฉ๋ฒ | ์ฅ์ | ๋จ์ |
|---|---|---|
| ์ ํ ํ์ฌ๋ฒ | ๊ตฌํ์ด ๊ฐ๋จ, ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ | ํด๋ฌ์คํฐ๋ง ๋ฌธ์ ๋ฐ์ ๊ฐ๋ฅ |
| ์ ๊ณฑ ํ์ฌ๋ฒ | ํด๋ฌ์คํฐ๋ง ๋ฌธ์ ์ํ ๊ฐ๋ฅ | ํ ์ด๋ธ ํฌ๊ธฐ ์ ์ฝ ์กด์ฌ |
| ์ด์ค ํด์ฑ | ํด๋ฌ์คํฐ๋ง ๋ฌธ์ ํด๊ฒฐ | ์ฐ์ฐ๋ ์ฆ๊ฐ ๊ฐ๋ฅ |
| ๋ถ๋ฆฌ ์ฐ๊ฒฐ๋ฒ | ์ ์ฐํ ์ถฉ๋ ํด๊ฒฐ | ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ ์ฆ๊ฐ |
ํด์ ์ถฉ๋์ ํด์ ๊ธฐ๋ฐ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ ๋ ํผํ ์ ์๋ ๋ฌธ์ ์ง๋ง, ์ ์ ํ ์ถฉ๋ ํด๊ฒฐ ์ ๋ต์ ์ฌ์ฉํ๋ฉด ์ฑ๋ฅ์ ์ต์ ํํ ์ ์์ต๋๋ค. ์ํฉ์ ๋ฐ๋ผ ๊ฐ๋ฐฉ ์ฃผ์๋ฒ(์ ํ ํ์ฌ, ์ ๊ณฑ ํ์ฌ, ์ด์ค ํด์ฑ) ๋๋ ๋ถ๋ฆฌ ์ฐ๊ฒฐ๋ฒ์ ์ ํํ์ฌ ์ ์ ํ ํ์ฉํด๋ณด์ธ์! ๐