Algorithm Theory

사전(Dictionary)

Meng's Computer 2020. 12. 12. 05:58

πŸ“’   μ •μ˜

  • 사전은 탐색 κ°€λŠ₯ν•œ ν˜•νƒœμ˜ (ν‚€,μ›μ†Œ)쌍 ν•­λͺ©λ“€μ˜ λͺ¨μŒμ„ λͺ¨λΈλ§ ν•œ 것이닀.

  • 사전에 κ΄€ν•œ μ£Όμš” μž‘μ—…
    1. 탐색(Searching)

    2. μ‚½μž…(Inserting)
    3. μ‚­μ œ(Deleting)

  • μ‚¬μ „μ—λŠ” 두 μ’…λ₯˜μ˜ 사전 μ‘΄μž¬ν•œλ‹€.
    1. λ¬΄μˆœμ‚¬μ „ ADT  (Ex. "가계뢀")  πŸ‘‰  "μˆœμ„œκ°€ μ—†λ‹€"
    2. μˆœμ„œμ‚¬μ „ ADT  (Ex. "μΆœμ„λΆ€", "백과사전") 
    πŸ‘‰  "ν•™λ²ˆ or 자음순,λͺ¨μŒμˆœ" λ“±μ˜ μ •λ ¬λœ μˆœμ„œκ°€ μžˆλ‹€.

  • 사전 μ‘μš©μ—λŠ” 두 가지
    1. 직접 μ‘μš©  πŸ‘‰  "μ—°λ½μ²˜ λͺ©λ‘", "μ‹ μš©μΉ΄λ“œ μ‚¬μš©μŠΉμΈ", "μΈν„°λ„·μ£Όμ†Œ 맀핑"
    2. κ°„μ ‘ μ‘μš©  πŸ‘‰  "μ•Œκ³ λ¦¬μ¦˜ μˆ˜ν–‰μ„ μœ„ν•œ 보쑰 데이터ꡬ쑰", "λ‹€λ₯Έ 데이터ꡬ쑰λ₯Ό κ΅¬μ„±ν•˜λŠ” μš”μ†Œ"

 

πŸ“’   νƒμƒ‰

  • 비곡식적 : 탐색(Search)은 데이터 μ§‘λ‹¨μœΌλ‘œλΆ€ν„° νŠΉμ •ν•œ 정보λ₯Ό μΆ”μΆœν•¨μ„ λ§ν•œλ‹€.

  • 곡식적 : 탐색(Search)은 μ‚¬μ „μœΌλ‘œ κ΅¬ν˜„λœ 데이터 μ§‘λ‹¨μœΌλ‘œλΆ€ν„° μ§€μ •λœ ν‚€(key)와 μ—°κ΄€λœ 데이터 μ›μ†Œλ₯Ό λ°˜ν™˜ν•¨μ„ λ§ν•œλ‹€.

  • 사전 κ΅¬ν˜„μ— λ”°λ₯Έ 탐색 기법

κ΅¬ν˜„ ν˜•νƒœ κ΅¬ν˜„ μ’…λ₯˜ 예 μ£Όμš” 탐색 기법
리슀트 λ¬΄μˆœμ‚¬μ „ ADT 기둝(log)파일 μ„ ν˜•νƒμƒ‰
μˆœμ„œμ‚¬μ „ ADT μΌλžŒν‘œ 이진탐색
트리 νƒμƒˆνŠΈλ¦¬ μ΄μ§„νƒμƒ‰νŠΈλ¦¬
AVL 트리
μŠ€ν”Œλ ˆμ΄ 트리
νŠΈλ¦¬νƒμƒ‰
ν—€μ‹œν…Œμ΄λΈ”     ν•΄μ‹±

 

πŸ“’   λ¬΄μˆœμ‚¬μ „ ADT

  • 무순리슀트λ₯Ό μ‚¬μš©ν•˜μ—¬ κ΅¬ν˜„λœ 사전  πŸ‘‰  사전 ν•­λͺ©λ“€μ„ μž„μ˜μ˜ μˆœμ„œλ‘œ λ¦¬μŠ€νŠΈμ— μ €μž₯
    ( μ΄μ€‘μ—°κ²°λ¦¬μŠ€νŠΈ λ˜λŠ” μ›ν˜• 배열을 μ‚¬μš© )

  • μ„±λŠ₯
    μ‚½μž… : O(1) μ†Œμš” πŸ‘‰ μƒˆλ‘œμš΄ ν•­λͺ©μ„ κΈ°μ‘΄ 리슀트의 맨 μ•ž λ˜λŠ” 맨 뒀에 μ‚½μž…ν•˜λ©΄ 되기 λ•Œλ¬Έ
    μ‚­μ œ : O(N) μ†Œμš” πŸ‘‰ (μ΅œμ•…μ˜ 경우)ν•­λͺ©μ΄ μ‘΄μž¬ν•˜μ§€ μ•Šμ„κ²½μš°, 리슀트 전체λ₯Ό μˆœνšŒν•΄μ•Ό ν•˜κΈ° λ•Œλ¬Έ
    탐색 : O(N) μ†Œμš” πŸ‘‰  (μ΅œμ•…μ˜ 경우)ν•­λͺ©μ΄ μ‘΄μž¬ν•˜μ§€ μ•Šμ„κ²½μš°, 리슀트 전체λ₯Ό μˆœνšŒν•΄μ•Ό ν•˜κΈ° λ•Œλ¬Έ

  • 효과적인 경우 : μ†Œκ·œλͺ¨ 사전, or μ‚½μž…μ€ λΉˆλ²ˆν•˜λ‚˜, νƒμƒ‰μ΄λ‚˜ μ‚­μ œλŠ” λ“œλ¬Έ 사전 ( Ex. μ„œλ²„μ˜ 둜그인 기둝 )

 

πŸ“’   λ¬΄μˆœμ‚¬μ „ μ„ ν˜•νƒμƒ‰ μ•Œκ³ λ¦¬μ¦˜

Alg findElement(K)		// λ°°μ—΄ Ver.
	input Array[0..N-1], Key K
    output element with key K

i <- 0				// 첫번째 λ°°μ—΄ 인덱슀 μ΄ˆκΈ°ν™”
while(i < N)			// λ°°μ—΄ λκΉŒμ§€ κ°ˆλ•ŒκΉŒμ§€ 반볡 
	if(A[i].key == K)	// A[i].key != λͺ©ν‘œ Keyκ°’
    	return A[i].key
    else				// A[i].key != λͺ©ν‘œ Keyκ°’
    	i <- i + 1		
return NoSuchKey

================================================================

Alg findElement(K)		// μ—°κ²°λ¦¬μŠ€ Ver.
	input doubly linked list with header H and trailer T, Key K
    output element with Key K

i <- H.next			// μ—°κ²°λ¦¬μŠ€νŠΈ Header에 λ‹€μŒ λ…Έλ“œλ‘œ μ΄ˆκΈ°ν™”
while(i != T)			// μ—°κ²°λ¦¬μŠ€νŠΈμ˜ 끝 Tailerμ „κΉŒμ§€ 
	if(i.key == K)		// i.key == λͺ©ν‘œ Keyκ°’
    	return i.elem
	else				// i.key == λͺ©ν‘œ Keyκ°’
    	i <- i.next
return NoSuchKey

 

 

πŸ“’   μˆœμ„œμ‚¬μ „ ADT

  • μˆœμ„œλ¦¬μŠ€νŠΈλ₯Ό μ‚¬μš©ν•˜μ—¬ κ΅¬ν˜„λœ 사전  πŸ‘‰  사전 ν•­λͺ©λ“€μ„ 배열에 κΈ°μ΄ˆν•œ λ¦¬μŠ€νŠΈμ— ν‚€λ‘œ μ •λ ¬λœ μˆœμ„œλ‘œ μ €μž₯

  • μ„±λŠ₯
    μ‚½μž… : O(N)  πŸ‘‰  μƒˆ ν•­λͺ©μ„ μ‚½μž…ν•˜κΈ° μœ„ν•œ 곡간 확보λ₯Ό μœ„ν•΄, (μ΅œμ•…μ˜ 경우) N개의 κΈ°μ‘΄ ν•­λͺ©μ„ 이동해야 ν•œλ‹€.
    μ‚­μ œ : O(N)  πŸ‘‰  ν•­λͺ©μ΄ μ‚­μ œλœ 곡간을 κΈ°μ‘΄ ν•­λͺ©λ“€λ‘œ λ©”κΎΈκΈ° μœ„ν•΄ (μ΅œμ•…μ˜ 경우) N개의 κΈ°μ‘΄ ν•­λͺ© 이동해야 ν•œλ‹€.탐색 : O(log(N))  πŸ‘‰  이진탐색을 μ‚¬μš©ν•˜λ©΄ κ°€λŠ₯ν•˜λ‹€.

  • 효과적인 경우 : μ†Œκ·œλͺ¨ 사전, or 탐색이 λΉˆλ²ˆν•˜λ‚˜, μ‚½μž… μ‚­μ œλŠ” λ“œλ¬Έ 사전 ( Ex. μ „ν™”λ²ˆν˜ΈλΆ€ )

 

πŸ“’   μ΄μ§„탐색(Binary Search)

  • ν‚€κ°’μœΌλ‘œ 된 "λ°°μ—΄(Array)"에 κΈ°μ΄ˆν•œ 리슀트둜 κ΅¬ν˜„λœ 사전에 λŒ€ν•΄ 탐색 μž‘μ—…μ„ μˆ˜ν–‰ν•œλ‹€.

  • λ°°μ—΄μ˜ 킀값듀은 λ°˜λ“œμ‹œ "μ •λ ¬(Sorted)"λ˜μ–΄ μžˆμ–΄μ•Ό ν•œλ‹€.

  • μž¬κ·€μ μΈ 방식 λΉ„μž¬κ·€μ  방식이 두 가지 λͺ¨λ‘ κ΅¬ν˜„ κ°€λŠ₯ν•˜λ‹€.

  • μž…λ ₯크기(N)의 둜그 수(log(N))에 ν•΄λ‹Ήν•˜λŠ” 수의 μž¬κ·€(or λΉ„μž¬κ·€)λ₯Ό μˆ˜ν–‰ν•œ ν›„ μ •μ§€ν•œλ‹€. ( Ex. 슀무고개 )

 

πŸ“’   μž¬κ·€μ  이진탐색

Alg findElement(K)
    input sorted Array A[0..N-1], K
    output element with key K
    
return rFE(K, 0, N-1)

=====================================
Alg rFE(K,l,r)			// l,r은 배열쑰사 λ²”μœ„μ˜ μ™Όμͺ½,였λ₯Έμͺ½ 인덱슀

if(l > r)
	return NoSuchKey
mid <- (l + r)/2			// μž¬κ·€ν˜ΈμΆœλ§ˆλ‹€, 쀑앙 인덱슀 midκ°’ κ΅¬ν•˜κ³ 
if(K = Key(A[mid]))		// A[mid]κ°’ = 찾아야될 keyκ°’, A[mid]κ°’ λ°˜ν™˜ 
	return element(A[mid])
elseif(K < Key(A[mid]))	// A[mid]κ°’ > 찾아야될 keyκ°’, (λ²”μœ„λ₯Ό l~(mid-1)둜 μž¬κ·€ 이진탐색 μž¬κ·€ν˜ΈμΆœ)
	return rFE(K, l, mid-1)
else					// A[mid]κ°’ < 찾아야될 keyκ°’, (λ²”μœ„λ₯Ό (mid+1)~r)둜 μž¬κ·€ 이진탐색 μž¬κ·€ν˜ΈμΆœ)
	return rFE(K, mid+1, r)

 

πŸ“’   λΉ„μž¬κ·€μ  이진탐색

Alg findElement(K)
	input sorted Array A[0..N-1], Key K
    output element with key K

l <- 0
r <- N-1
while(l <= r)			// μž¬κ·€ν˜ΈμΆœ λŒ€μ‹ ,반볡문 μ‚¬μš©
	mid <- (l + r) / 2	// 맀 κ³Όμ •, λ°°μ—΄μ˜ 쀑앙 인덱슀 mid κ΅¬ν•˜κ³ 
    if(K == Key(A[mid]))	// A[mid] == λͺ©ν‘œ Key
    	return element(A[mid])
    elseif(K < key(A[mid]))	// A[mid] > λͺ©ν‘œ Key
		r <- (mid - 1)
	else				// A[mid] < λͺ©ν‘œ Key
    	l <- (mid + 1)
return NoSuchKey

πŸ“’   μ΄μ§„탐색 μˆ˜ν–‰ 예

 

πŸ“’   [ μ°Έκ³  ] μž¬κ·€ μ•Œκ³ λ¦¬μ¦˜ πŸ‘‰ λΉ„μž¬κ·€ μ•Œκ³ λ¦¬μ¦˜ μ „ν™˜ν•˜κΈ° μœ„ν•œ 일반적인 μš”λ Ή

  1. μž¬κ·€ν˜ΈμΆœμ„ 반볡문으둜 λŒ€μ²΄ν•œλ‹€.

  2. μž¬κ·€μ˜ λ§€κ°œλ³€μˆ˜λ₯Ό 반볡문의 μ œμ–΄λ³€μˆ˜λ‘œ μ „ν™˜ν•œλ‹€.

  3. 졜초의 μž¬κ·€ν˜ΈμΆœμ— μ‚¬μš©ν•˜λŠ” λ§€κ°œλ³€μˆ˜ 값을 반볡문 μ§„μž… μ „ μ΄ˆκΈ°ν™”λ‘œ μ „ν™˜ν•œλ‹€.

  4. μž¬κ·€μ˜ BaseCaseλ₯Ό 반볡문의 μ’…λ£Œ 쑰건으둜 μ „ν™˜ν•œλ‹€.

728x90
λ°˜μ‘ν˜•