๐์๋ฃ๊ตฌ์กฐ/์๊ณ ๋ฆฌ์ฆ - 5
ํ์ต๊ธฐ๋ก
์ค๋ ๋ค์ ๊ฐ์ ๋ชฉ๋ก
- ํด์ฌ ํ ์ด๋ธ - 1
- ํด์ฌ ํ ์ด๋ธ - 2
- ํด์ฌ ํ ์ด๋ธ - 3
- ํด์ฌ ํ ์ด๋ธ - 4
- ํด์ฌ ํ ์ด๋ธ - 5
ํด์ฌ + ํ ์ด๋ธ(Hash + Table)
ํด์ฌ ํ
์ด๋ธ์ ํด์ฌ + ํ
์ด๋ธ์ด๋ค.
ํด์ฌ๋ฅผ ํตํด ํด์ฌ๊ฐ์ ๊ตฌํ๊ณ , ํด์ฌ๊ฐ๋ฅผ ํตํด ํ
์ด๋ธ์ ์ ์ฅํ๊ฑฐ๋ ๋ฐ์ดํฐ๋ฅผ ์ฐพ๋๋ค.
์ ๋๋ก ์ดํดํ๊ธฐ ์ํด์๋ ํด์ฌ์ ํ ์ด๋ธ์ด ๋ฌด์จ๋ง์ธ์ง ์์์ผ๊ฒ ๋ค.
ํด์ฌ?
์ด๋ค ๋ฐ์ดํฐ์ ๊ณ ์ ๋ ๊ธธ์ด๋ก ๋ณํํ๋ ๊ฒ
์ฉ์ด
- ํด์ฌ ํจ์(hash function) : ํค(key)๋ฅผ ๋ฃ์ผ๋ฉด ๊ณ ์ ๋ ๊ธธ์ด์ ํด์ฌ ๊ฐ์ด ๋์ค๋ ํจ์ (ํด์ฑ(hashing)์ ํ๋ ํจ์)
- ํด์ฌ ๊ฐ(hash value), ํด์ฌ ์ฃผ์(hash address) : ํค(key)๋ฅผ ํด์ฌ ํจ์์ ๋ฃ์์ ๋ ๋์ค๋ ๊ฐ, ์ด๋ฅผ ํตํด ๋ฐ์ดํฐ๊ฐ ์ ์ฅ๋ ์ฌ๋กฏ์ ์ ๊ทผํ ์ ์๋ค.
- ํด์ฌ ํ ์ด๋ธ(hash table) : ํด์ฌ ์ฃผ์(ํด์ฌ ๊ฐ)๊ณผ ์ฌ๋กฏ์ผ๋ก ๊ตฌ์ฑ๋ ์๋ฃ๊ตฌ์กฐ
- ์ฌ๋กฏ(slot) : ํด์ฌ์ฃผ์(ํด์ฌ ๊ฐ)์ ๋์๋๋ ๋ฐ์ดํฐ๊ฐ ์ ์ฅ๋๋ ๊ณต๊ฐ
- ํค(key) : ๋ฐ์ดํฐ๋ฅผ ํตํด ์์ฑํ๋ ํค, ํด์ฌํจ์์ ๋ฃ์ด์ ํด์ฌ ๊ฐ์ ๊ตฌํ๊ธฐ ์ํด ์ฌ์ฉ๋๋ค. (๋ฐ์ดํฐ๋ฅผ ๊ทธ๋๋ก ์ฌ์ฉํ๊ธฐ๋ ํ๋ค.)
ํด์ฌํ ์ด๋ธ
๋ฐ์ดํฐ๋ฅผ ํตํด ํค๋ฅผ ๊ตฌํ๊ณ , ํค๋ฅผ ํด์ฌํจ์์ ๋ฃ์ด์ ํด์ฌ๊ฐ์ ๊ฐ์ ธ์ค๊ณ , ์ด๋ฅผ ํด์ฌํ ์ด๋ธ์์ ์ง์ ์ ์ฅํ๊ฑฐ๋ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด์จ๋ค.
๋ฐ์ดํฐ -> ํค -> ํด์ฌ ๊ฐ
๋ฐ์ดํฐ ์ ์ฅ๊ณผ์
- ๋ฐ์ดํฐ๋ฅผ ํค ์์ฑํจ์์ ๋ฃ์ด ํค๋ฅผ ์์ฑํ๋ค. keyGen(Data) -> Key
- ํค๋ฅผ ํด์ฌํจ์์ ๋ฃ์ด ํด์ฌ ๊ฐ์ ๊ตฌํ๋ค. hashFunction(Key) -> HashValue
- ํด์ฌ ๊ฐ์ ํตํด ํด์ฌํ ์ด๋ธ์ ์ฌ๋กฏ์ ์ ์ฅํ๋ค. hashTable[HashValue] = Data
๋ฐ์ดํฐ ์ฝ์ด์ค๊ธฐ
- ๋ฐ์ดํฐ๋ฅผ ํค ์์ฑํจ์์ ๋ฃ์ด ํค๋ฅผ ์์ฑํ๋ค. keyGen(Data) -> Key
- ํค๋ฅผ ํด์ฌํจ์์ ๋ฃ์ด ํด์ฌ ๊ฐ์ ๊ตฌํ๋ค. hashFunction(Key) -> HashValue
- ํด์ฌํ ์ด๋ธ์ ํด์ฌ ๊ฐ์ ํด๋นํ๋ ์ฌ๋กฏ์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด์จ๋ค. hashTable[HashValue]
๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ํด์ฌํ ์ด๋ธ ๊ตฌํ
hashTable = [0 for i in range(1,10)]
def getKey(data):
return ord(data[0]) # data[0]์ ์์คํค์ฝ๋๊ฐ
def getHash(key):
return key % 10
def addData(data):
hashTable[getHash(getKey(data[0]))] = data
def readData(data):
return hashTable[getHash(getKey(data[0]))]
addData(["Admin", "010-2020-2020"])
addData(["Baby", "010-1010-1010"])
readData("Admin")
๋ฌธ์ ์ : ๊ฐ์ ํด์ฌ, ํค๋ฅผ ๊ฐ์ง๋ ๊ฐ๋ค์ด ์กด์ฌํ ์ ์๋ค.
๋ฌธ์ ๋ฐ์ ์์
addData(["Admin", "010-2020-2020"])
addData(["Kson", "010-1010-1010"])
readData("Admin")
๋ถ๋ช
Admin๊ณผ Kson์ ์ถ๊ฐํ๊ณ , Admin์ ์ฐพ์๋๋ฐ Kson๊ฐ์ด ๋ถ๋ฌ์์ก๋ค?
์ด๋ A์ ์์คํค์ฝ๋๊ฐ์ 10์ผ๋ก ๋๋ ๋๋จธ์ง์ธ 5, K์ ์์คํค์ฝ๋๊ฐ์ 10์ผ๋ก ๋๋ ๋๋จธ์ง์ธ 5๋ก ๊ฐ์ ํด์ ๊ฐ์ ๊ฐ์ง๊ฒ๋์๋ค.
๋ฐ๋ผ์ ํด์ ๊ฐ์ด 5์ธ ์ฌ๋กฏ์ Admin๋ฐ์ดํฐ๊ฐ ์ฐ์ด๊ณ , ๊ธฐ์กด ๋ฐ์ดํฐ๋ฅผ ์ง์ฐ๊ณ ๊ฐ์ ์ฌ๋กฏ์ Kson๊ฐ์ด ๋ฎ์ด์์์ก๋ค.
๋ํ ๋ฐ์ดํฐ๋ฅผ ์ฝ์๋๋ ํด์ ๊ฐ์ด 5์ธ ์ฌ๋กฏ์ ์๋ ๋ฐ์ดํฐ์ธ Kson์ด ์ฝํ๊ฒ ๋ ๊ฒ์ด๋ค.
์ถฉ๋(Collision)?
์๋ก ๋ค๋ฅธ ๋ฐ์ดํฐ๊ฐ ๊ฐ์ ํด์๊ฐ์ ๊ฐ์ง๋ ๊ฒฝ์ฐ๋ฅผ ์ถฉ๋์ด๋ผ ํ๋ค.
๋ฐ๋ก ์์ ๊ฐ์ ๊ฒฝ์ฐ๊ฐ ์ถฉ๋์ ๋ํ์ ์ธ ์์ด๋ค.
์ถฉ๋์ ํด๊ฒฐํ๊ธฐ ์ํด์๋ ๋ํ์ ์ผ๋ก Chaining ๊ธฐ๋ฒ๊ณผ, Linear Probling ๊ธฐ๋ฒ์ด ์กด์ฌํ๋ค.
์ถฉ๋ ํด๊ฒฐ ๊ธฐ๋ฒ๋ค
ํฌ๊ฒ Open/Close ํด์ฑ ๊ธฐ๋ฒ์ผ๋ก ๋๋๋ค.
๋๋ ํด์ฌ ํ
์ด๋ธ์ ๊ณต๊ฐ์ ํ๋ํ๊ณ ํด์ฌํจ์๋ฅผ ๋ณ๊ฒฝํ๋ค.(์ถฉ๋์ด ์ ์๊ฒฝ์ฐ๋ ์ ์ธ)
๊ฐ์ ํด์๊ฐ์ผ๋ก ์ธํด ์ถฉ๋์ด ๋ฐ์ํ๊ธฐ์ ์ํ๋ ๊ฐ์ ์ฐพ๊ธฐ ์ํ key๋ฅผ ๊ฐ์ด ์ ์ฅํ๋ค.
(๊ทธ๋ ๋ค๋ฉด key๋ ๋
๋ฆฝ์ ์ธ ๊ฐ์ด ๋์ด์ผ๊ฒ ๋ค. ๊ฐ์ฅ ํ์คํ ๋ฐฉ๋ฒ์ผ๋ก๋ ๋ฐ์ดํฐ๋ฅผ ๊ทธ๋๋ก ์ฐ๋๋ฐฉ๋ฒ)
Chaining (Open hasing ๊ธฐ๋ฒ ์ค ํ๋)
์๋ก์ด ๊ณต๊ฐ์ ์ถ๊ฐํด์ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ
์ถฉ๋์ด ์ผ์ด๋๋ฉด ํด๋น ์ฌ๋กฏ์ ์ฐ๊ฒฐ๋ฆฌ์คํธ ๊ตฌ์กฐ๋ก ๋ค์ ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํ๋ ๋ฐฉ๋ฒ ํ์ํ ๋๋ ํด์ฌ๊ฐ์ ๋์๋๋ ์ฌ๋กฏ์์ ํ์ํ๋ค.
์ค๋ณต ํด์๊ฐ์ ๊ฐ๋ ๋ฐ์ดํฐ๊ฐ ์ถ๊ฐ๋ ๋๋ง๋ค ์ฌ๋กฏ์ด ์ถ๊ฐ๋๋ค.
์๋๋ 1๋ฒ ์ฌ๋กฏ์์ ์ค๋ณต์ด ์ผ์ด๋ ๊ฒฝ์ฐ
Anthor๋ฅผ ์ถ๊ฐํ๋ ค๋๋ฐ Andy์ Anthor๊ฐ ์ค๋ณต์ด ์ผ์ด๋์ Anthor๋ฅผ Andy๋ค์ ์ถ๊ฐํ๋ค.
Linear Probling (Close Hashing ๊ธฐ๋ฒ ์ค ํ๋)
ํด์ํ ์ด๋ธ ๋ด์ ๋น ๊ณต๊ฐ์ ํ์ฉํ๋ ๋ฐฉ๋ฒ
์ถฉ๋์ด ์ผ์ด๋๋ฉด ํด๋น ์ฌ๋กฏ๋ถํฐ ๋ค์ ์ฌ๋กฏ๋ค ์ค ๋น ์ฌ๋กฏ์ ์ฐพ์ ํด๋น ์ฌ๋กฏ์ ์ฝ์ ํ๋ค. ํ์ํ ๋๋ ํด์ฌ๊ฐ์ ๋์๋๋ ์ฌ๋กฏ๋ถํฐ ๋ค์ ์ฌ๋กฏ์ค์์ ํ์ํ๋ค.
์ฌ๋กฏ๋ค์ด ํด์ํ ์ด๋ธ์ ์ฝ์ ํ ๋ฐ์ดํฐ์ ์๋งํผ ๋ฏธ๋ฆฌ ์ค๋น๋์ด ์์ด์ผ ํ๋ค.
์๋๋ 1๋ฒ ์ฌ๋กฏ์์ ์ค๋ณต์ด ์ผ์ด๋ ๊ฒฝ์ฐ
Anthor๋ฅผ ์ถ๊ฐํ๋ ค๋๋ฐ Andy์ Anthor๊ฐ ์ค๋ณต์ด ์ผ์ด๋ฌ๋ค.
๋ค์ ์ฌ๋กฏ์ธ 2๋ฒ์ฌ๋กฏ๋ถํฐ ๋น์ด์๋ ์ฌ๋กฏ์ ์ฐพ๊ฒ๋๋๋ฐ, ๋ง์นจ 2๋ฒ ์ฌ๋กฏ์ด ๋น์ด์์ด์ 2๋ฒ์ Anthor๋ฅผ ์ถ๊ฐํ๋ค.
๋น๋ฒํ ์ถฉ๋์ด ์๊ธฐ๋ ๊ฒฝ์ฐ
์ฌ๋ฌ ๋ฐ์ดํฐ๋ค์ด ์ถฉ๋์ด ์๊พธ ์๊ธฐ๋ฉด ํด์ํ
์ด๋ธ์ 2๋ฐฐ ํ์ฅํ๋ค๊ณ ํ๋ค.
๋ค๋ง ์ถฉ๋์ด ๊ณจ๊ณ ๋ฃจ ์ฌ๋กฏ๋ค์ ๋ถํฌ๋์ง ์์ ๊ฒฝ์ฐ๋ ํด์ํจ์๋ฅผ ๋ณ๊ฒฝํ๋ ๊ฒ์ด ์ข๊ฒ ๋ค.
์๋์ฒ๋ผ ์ถฉ๋์ด ์ด๋์ ๋ ๊ณจ๊ณ ๋ฃจ ๋์๋ค๋ฉด, ํด์ํ
์ด๋ธ์ ํ์ฅํ๋ ๊ฒ์ด ์ข๊ฒ ๋ค.
์๋ฌด๋๋ ์ถฉ๋์ด ์๊ธฐ์ง ์๋๊ฒ ์ต๊ณ ๊ธดํ๋ค.
ํ์ด์ฌ์์ ํด์ํจ์ : hash()
hash() : ์ด ํจ์๋ ์คํํ ๋๋ง๋ค ๊ฐ์ด ๋ฌ๋ผ์ง ์ ์๋ค. hashlib : ํด์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ, sha1, sha256๋ฑ์ ํฌํจํ๊ณ ์๋๋ฐ ์๋์์ ์ค๋ช ํ๊ฒ ๋ค.
์ ๋ช ํ ํด์ํจ์ : sha
SHA(Secure Hash Algorithm) : ๋์ถฉ ์์ ํ๋ค๋ ๋ป์ด๋ค.
sha-1์ ์ด๋ฏธ ์ถฉ๋์ด ๋ฐ์ํ๊ณ ,
sha-2๋ ์์ง ์ทจ์ฝ์ ์ด ์๋ ๊ฒ ๊ฐ๋ค. ๋ง์ ๊ธฐ์
๋ค์ด ์ฌ์ฉํ๊ณ ์์ผ๋ฉฐ, ๋นํธ์ฝ์ธ ๋ํ SHA-256์ ์ฌ์ฉํ๋ค.
sha1/sha256 ์์
import hashlib
data = 'test'.encode()
hash_object = hashlib.sha1() # ์ฌ๊ธฐ์ sha1 -> sha256๋ง ํด์ฃผ๋ฉด sha256์ผ๋ก ๋ฐ๋๋ค.
hash_object.update(data)
hex_dig = hash_object.hexdigest()
์๊ฐ๋ณต์ก๋
์ผ๋ฐ์ ์ธ ๊ฒฝ์ฐ(Collision์ด ์์) : O(1)
Data -> Key -> HashValue๋ก ์์์๊ฐ์ผ๋ก ์ ๊ทผ
์ต์
์ ๊ฒฝ์ฐ(Collision์ด ์์) : O(n)
Data -> Key -> HashValue -> ํ์์ผ๋ก n์๊ฐ ๋ด๋ก ์ ๊ทผ
ํ์ค์์ ํด์
๋ํ์ ์ผ๋ก ๋ธ๋ก์ฒด์ธ์ ๋ค์ด๊ฐ๋ค๊ณ ํ๋ค.
๋ธ๋ก์ฒด์ธ์ ์ ๋ชจ๋ฅด๊ฒ ๊ณ ..
ํด์๋ฅผ ํตํด์ ํ์ผ ๋ฑ์ ์๋ณ์กฐ ๊ฒ์ฆํ ๋ ์ฌ์ฉํ๋ค.
์ผ๋ถ ์ฌ์ดํธ์๋ ํด์๊ฐ์ ๊ณต๊ฐํด์ ๋ค์ด๋ฐ์ ํ์ผ์ ํด์๊ฐ๊ณผ ๋น๊ต๋ฅผ ํตํด ์๋ณ์กฐ ๋ ํ์ผ์ธ์ง ํ์ธํ ์ ์๋๋ก ๋์ด์๋ค.
๋ ๋ก๊ทธ์ธ/ํ์๊ฐ์
์ ๋น๋ฐ๋ฒํธ๋ฅผ ํด์ฑํ์ฌ ์๋ฒ์ ์ ์ฅํ๊ฒ ๋๊ณ , ๋ก๊ทธ์ธ์ ํด์๊ฐ์ ๋น๊ตํด์ ๋ก๊ทธ์ธ ์ ์ฐจ๋ฅผ ๋ฐ๊ฒ ๋๋ค.
๋ง์ง๋ง
ํด์๊ฐ ์ด๋ค๋ฐฉ์์ผ๋ก ์๋ํ๋์ง ์ดํดํ๋๊ฒ ์ค์ํ๋ค.
5๊ฐ์ ๊ฐ์๋ก ๊ตฌ์ฑ๋์ด ์๋๋ฐ, ๋๋ผ๋ง์ฒ๋ผ ๊ทน์ ์ผ๋ก ๋๋ ๋๋์ด ์๋๋ผ ๋ฑ ๋ง๊ฒ ํํธ๋ณ๋ก ์ ๋์ด์ฃผ์
์ ๋๋ฌด ์ ๋ค์๋ค.
๋๊ธ๋จ๊ธฐ๊ธฐ