[자료구조/알고리즘] 해시(Hash) - 해시 테이블, 파이썬 딕셔너리(Python Dictionary)

해쉬 테이블 (Hash Table)

1. 해쉬 구조
* Hash Table: 키(Key)에 데이터(Value)를 저장하는 데이터 구조
  - Key를 통해 바로 데이터를 받아올 수 있으므로, 속도가 획기적으로 빨라짐
  - 파이썬 딕셔너리(Dictionary) 타입이 해쉬 테이블의 예: Key를 가지고 바로 데이터(Value)를 꺼냄
  - 보통 배열로 미리 Hash Table 사이즈만큼 생성 후에 사용 (공간과 탐색 시간을 맞바꾸는 기법)
  - <font color='#BF360C'>단, 파이썬에서는 해쉬를 별도 구현할 이유가 없음 - 딕셔너리 타입을 사용하면 됨</font>

 

2. 알아둘 용어

• 해쉬(Hash) 
  • 임의 값을 고정 길이로 변환하는 것
  • 데이터를 다루는 기법 중 하나로 검색과 저장이 아주 유용한 구조
  • key와 value 쌍으로 데이터를 저장한다.
• * 해쉬 테이블(Hash Table): 키 값의 연산에 의해 직접 접근이 가능한 데이터 구조
• 해싱 함수(Hashing Function)
  • Key에 대해 산술 연산을 이용해 데이터 위치를 찾을 수 있는 함수
  • 임의의 길이를 갖는 메시지를 입력받아 고정된 길이의 해시값을 출력하는 함수
• * 해쉬 값(Hash Value) 또는 해쉬 주소(Hash Address): Key를 해싱 함수로 연산해서, 해쉬 값을 알아내고, 이를 기반으로 해쉬 테
• 이블에서 해당 Key에 대한 데이터 위치를 일관성있게 찾을 수 있음
• * 슬롯(Slot): 한 개의 데이터를 저장할 수 있는 공간
• * 저장할 데이터에 대해 Key를 추출할 수 있는 별도 함수도 존재할 수 있음

해시 함수

hash('a')   #3831149060446305003
hash(15)   #15
hash(12.34)   #783986623132655628

 

3. hash table 만들기

* 참고: 파이썬 list comprehension - https://www.fun-coding.org/PL&OOP5-2.html

파이썬 특수 문법(데코레이터, 이터레이터등): 파이썬 Comprehension - 잔재미코딩

 

4. 자료 구조 해쉬 테이블의 장단점과 주요 용도

- 장점
  - 데이터 저장/읽기 속도가 빠르다. (검색 속도가 빠르다.)
  - 해쉬는 키에 대한 데이터가 있는지(중복) 확인이 쉬움
- 단점 
  - 일반적으로 저장공간이 좀더 많이 필요하다.
  - **여러 키에 해당하는 주소가 동일할 경우 충돌을 해결하기 위한 별도 자료구조가 필요함**
- 주요 용도
  - 검색이 많이 필요한 경우
  - 저장, 삭제, 읽기가 빈번한 경우
  - 캐쉬 구현시 (중복 확인이 쉽기 때문)

 

5. 해시 테이블 구현 코드

hash_table = list([0 for i in range(8)])

def get_key(data):
    return hash(data)

def hash_function(key):
    return key % 8

def save_data(data, value):
    hash_address = hash_function(get_key(data))
    hash_table[hash_address] = value
    
def read_data(data):
    hash_address = hash_function(get_key(data))
    return hash_table[hash_address]

#예시
save_data('Dave', '0102030200')
save_data('Andy', '01033232200')

read_data('Dave')

 

6. 충돌(Collision) 해결 알고리즘 (좋은 해쉬 함수 사용하기)

> 해쉬 테이블의 가장 큰 문제는 충돌(Collision)의 경우입니다.
> 이 문제를 충돌(Collision) 또는 해쉬 충돌(Hash Collision)이라고 부릅니다.

 

6.1. Chaining 기법
- **개방 해슁 또는 Open Hashing 기법** 중 하나: 해쉬 테이블 저장공간 외의 공간을 활용하는 기법
- 충돌이 일어나면, 링크드 리스트라는 자료 구조를 사용해서, 링크드 리스트로 데이터를 추가로 뒤에 연결시켜서 저장하는 기법

hash_table = list([0 for i in range(8)])

def get_key(data):
    return hash(data)

def hash_function(key):
    return key % 8

def save_data(data, value):
    index_key = get_key(data)
    hash_address = hash_function(index_key)
    if hash_table[hash_address] != 0:
        for index in range(len(hash_table[hash_address])):
            if hash_table[hash_address][index][0] == index_key:
                hash_table[hash_address][index][1] = value
                return
        hash_table[hash_address].append([index_key, value])
    else:
        hash_table[hash_address] = [[index_key, value]]
    
def read_data(data):
    index_key = get_key(data)
    hash_address = hash_function(index_key)

    if hash_table[hash_address] != 0:
        for index in range(len(hash_table[hash_address])):
            if hash_table[hash_address][index][0] == index_key:
                return hash_table[hash_address][index][1]
        return None
    else:
        return None


#예시. 참고로 Dd와 Data의 hash_address가 같아야 함
save_data('Dd', '1201023010')
save_data('Data', '3301023010')
read_data('Dd')

 

6.2. Linear Probing 기법
- **폐쇄 해슁 또는 Close Hashing 기법** 중 하나: 해쉬 테이블 저장공간 안에서 충돌 문제를 해결하는 기법
- 충돌이 일어나면, 해당 hash address의 다음 address부터 맨 처음 나오는 빈공간에 저장하는 기법
  - 저장공간 활용도를 높이기 위한 기법

hash_table = list([0 for i in range(8)])

def get_key(data):
    return hash(data)

def hash_function(key):
    return key % 8

def save_data(data, value):
    index_key = get_key(data)
    hash_address = hash_function(index_key)
    if hash_table[hash_address] != 0:
        for index in range(hash_address, len(hash_table)):
            if hash_table[index] == 0:
                hash_table[index] = [index_key, value]
                return
            elif hash_table[index][0] == index_key:
                hash_table[index][1] = value
                return
    else:
        hash_table[hash_address] = [index_key, value]

def read_data(data):
    index_key = get_key(data)
    hash_address = hash_function(index_key)
    
    if hash_table[hash_address] != 0:
        for index in range(hash_address, len(hash_table)):
            if hash_table[index] == 0:
                return None
            elif hash_table[index][0] == index_key:
                return hash_table[index][1]
    else:
        return None

 

6.3. 빈번한 충돌을 개선하는 기법
- 해쉬 함수을 재정의 및 해쉬 테이블 저장공간을 확대

hash_table = list([None for i in range(16)])

def hash_function(key):
    return key % 16

 

참고: 해쉬 함수와 키 생성 함수
- 파이썬의 hash() 함수는 실행할 때마다, 값이 달라질 수 있음
- 유명한 해쉬 함수들이 있음: SHA(Secure Hash Algorithm, 안전한 해시 알고리즘)
  - 어떤 데이터도 유일한 고정된 크기의 고정값을 리턴해주므로, 해쉬 함수로 유용하게 활용 가능

import hashlib

data = 'test'.encode()
hash_object = hashlib.sha1()
hash_object = hashlib.sha256()
hash_object.update(data)
hex_dig = hash_object.hexdigest()
print (hex_dig)

import hashlib

hash_table = list([0 for i in range(8)])

def get_key(data):
        hash_object = hashlib.sha256()
        hash_object.update(data.encode())
        hex_dig = hash_object.hexdigest()
        return int(hex_dig, 16)

def hash_function(key):
    return key % 8

def save_data(data, value):
    index_key = get_key(data)
    hash_address = hash_function(index_key)
    if hash_table[hash_address] != 0:
        for index in range(hash_address, len(hash_table)):
            if hash_table[index] == 0:
                hash_table[index] = [index_key, value]
                return
            elif hash_table[index][0] == index_key:
                hash_table[index][1] = value
                return
    else:
        hash_table[hash_address] = [index_key, value]

def read_data(data):
    index_key = get_key(data)
    hash_address = hash_function(index_key)
    
    if hash_table[hash_address] != 0:
        for index in range(hash_address, len(hash_table)):
            if hash_table[index] == 0:
                return None
            elif hash_table[index][0] == index_key:
                return hash_table[index][1]
    else:
        return None

 

해시 구현 방법

hash = dict()   
hash = {}   

hash[1] = 'apple'
hash['banana'] = 3
hash[(4,5)] = [1,2,3]
hash[10] = dict({1:'a', 2:'b'})

hash.pop(1)   #apple이 삭제됨
del hash[1]
hash.pop('banana')   #3이 삭제됨
del hash['banana']
hash.pop((4,5))   #[1,2,3]이 삭제됨
del hash[(4,5)]

#hash[[1,2,3]] = 5   #오류
#hash[{1,2,3}] = 'orange'   #오류

hash.keys()
hash.values()
hash.items()

 

hash = dict()
for i in range(1,6):
	hash[i] = i**2
	
for k in hash.keys():
	print(k)   #1,2,3,4,5

for v in hash.values():
	print(v)   #1,4,9,16,26

for k,v in hash.items():
	print(k, v)   #1 1, 2 4, 3 9, 4 16, 5 25

 

hash = dict({1:10, 3:12, 5:7, 7:6, 4:5})

sorted(hash.keys(), key = lambda x:x)   #key만
sorted(hash.values(), values = lambda x:x)   #value만
sorted(hash.items(), key = lambda x:x)   #key를 기준으로 둘 다

sorted(hash.keys(), key = lambda x:-x)   #key만 내림차순
sorted(hash.values(), values = lambda x:-x)   #value만 내림차순
sorted(hash.items(), key = lambda x:-x)   #에러
sorted(hash.items(), key = lambda x:-x[0])   #key를 기준으로 둘 다 내림차순
sorted(hash.items(), key = lambda x:(x[1], x[0]))   #value 오름차순, key 오름차순
sorted(hash.items(), key = lambda x:(-x[0], x[1]))   #key 내림차순, value 오름차순

 

#defaultdict

from collections import defaultdict

list_dict = defaultdict(list)	#int, str 등...
print (list_dict['key1'])

 

7. 시간 복잡도

- 일반적인 경우(Collision이 없는 경우)는 O(1)
- 최악의 경우(Collision이 모두 발생하는 경우)는 O(n)

> 해쉬 테이블의 경우, 일반적인 경우를 기대하고 만들기 때문에, 시간 복잡도는 O(1) 이라고 말할 수 있음

### 검색에서 해쉬 테이블의 사용 예
- 16개의 배열에 데이터를 저장하고, 검색할 때 O(n)
- 16개의 데이터 저장공간을 가진 위의 해쉬 테이블에 데이터를 저장하고, 검색할 때 O(1)