Algorithm Theory

ํ•ด์‹œํ…Œ์ด๋ธ”(Hash Table)

Meng's Computer 2020. 12. 13. 00:14

๐Ÿ“ข  ํ•ด์‹œํ…Œ์ด๋ธ”(Hash Table)

  • (ํ‚ค-์ฃผ์†Œ) ๋งคํ•‘์— ์˜ํ•ด ๊ตฌํ˜„๋œ ์‚ฌ์ „ ADT
    ๐Ÿ‘‰ ์˜ˆ : ์ปดํŒŒ์ผ๋Ÿฌ์˜ ์‹ฌ๋ณผ ํ…Œ์ด๋ธ”, ํ™˜๊ฒฝ๋ณ€์ˆ˜๋“ค์˜ ๋ ˆ์ง€์Šคํ† ๋ฆฌ

  • ํ•ด์‹œํ…Œ์ด๋ธ” = ๋ฒ„์ผ“ ๋ฐฐ์—ด + ํ•ด์‹œํ•จ์ˆ˜
    ๐Ÿ‘‰ ํ•ญ๋ชฉ๋“ค์˜ ํ‚ค๋ฅผ ์ฃผ์†Œ(์ฆ‰, ๋ฐฐ์—ด์ฒจ์ž)๋กœ ๋งคํ•‘ํ•จ์œผ๋กœ์„œ 1์ฐจ์› ๋ฐฐ์—ด์— ์‚ฌ์ „ ํ•ญ๋ชฉ๋“ค์„ ์ €์žฅํ•œ๋‹ค.
  • ์„ฑ๋Šฅ
    ๐Ÿ‘‰ ํƒ์ƒ‰,์‚ฝ์ž…,์‚ญ์ œ : ์ตœ์•…์˜ ๊ฒฝ์šฐ O(N), ๊ทธ๋Ÿฌ๋‚˜ ๊ธฐ๋Œ€์‹œ๊ฐ„ O(1)

 

๐Ÿ“ข  ๋ฒ„์ผ“๋ฐฐ์—ด(Bucket Array)

ํ•ด์‹œํ…Œ์ด๋ธ” ๋ฒ„์ผ“๋ฐฐ์—ด ์˜ˆ ( M = 13 ์ธ ๊ฒฝ์šฐ )

  • ํ‚ค๊ฐ€ ์œ ์ผํ•œ ์ •์ˆ˜๋ฉฐ [0...M-1] ๋ฒ”์œ„์— ์ž˜ ๋ถ„ํฌ๋˜์–ด ์žˆ๋‹ค๋ฉด, ํ•ด์‹œํ…Œ์ด๋ธ”์—์„œ์˜ ํƒ์ƒ‰, ์‚ฝ์ž…, ์‚ญ์ œ์— O(1) ์†Œ์š”

  • ๋‘ ๊ฐ€์ง€ ์ค‘์š”ํ•œ ๊ฒฐํ•จ

    ๐Ÿ‘‰ O(N) ๊ณต๊ฐ„์„ ์‚ฌ์šฉํ•˜๋ฏ€๋กœ, M์ด N์— ๋น„ํ•ด ๋งค์šฐ ํฌ๋ฉด, ๊ณต๊ฐ„ ๋‚ญ๋น„
    ๐Ÿ‘‰ ํ‚ค๋“ค์ด [0...M-1] ๋ฒ”์œ„ ๋‚ด์˜ ์œ ์ผํ•œ ์ •์ˆ˜์—ฌ์•ผ ํ•˜์ง€๋งŒ, ์ด๋Š” ์ข…์ข… ๋น„ํ˜„์‹ค์ 
  • ์„ค๊ณ„ ๋ชฉํ‘œ

    ๐Ÿ‘‰ ๊ทธ๋Ÿฌ๋ฏ€๋กœ ํ•ด์‹œํ…Œ์ด๋ธ” ๋ฐ์ดํ„ฐ๊ตฌ์กฐ๋ฅผ ์ •์˜ํ•  ๋•Œ๋Š”, ํ‚ค๋ฅผ [0...M-1] ๋ฒ”์œ„ ๋‚ด์˜ ์ •์ˆ˜๋กœ ๋งคํ•‘ํ•˜๋Š” ์ข‹์€ ๋ฐฉ์‹๊ณผ
    ๋ฒ„์ผ“๋ฐฐ์—ด์„ ๊ตฌ์„ฑํ•ด์•ผ ํ•œ๋‹ค.

 

๐Ÿ“ข  ํ•ด์‹œํ•จ์ˆ˜ ๋ฐ ํ•ด์‹œํ…Œ์ด๋ธ”

  • ํ•ด์‹œํ•จ์ˆ˜(Hash Function), h :  ์ฃผ์–ด์ง„ ํ˜•์˜ ํ‚ค๋ฅผ ๊ณ ์ •๋ฒ”์œ„ [0...M-1]๋กœ ๋งคํ•‘

    ๐Ÿ‘‰ ์˜ˆ : h(x) = x % M ( h๋Š” ์ •์ˆ˜ ํ‚ค x์— ๋Œ€ํ•œ ํ•ด์‹œํ•จ์ˆ˜ )
  • ์ •์ˆ˜ h(x) : ํ‚ค x์˜ ํ•ด์‹œ๊ฐ’(Hash value)
  • ์ฃผ์–ด์ง„ ํ‚ค ํ˜•์˜ ํ•ด์‹œํ…Œ์ด๋ธ”์€ ๋‹ค์Œ ๋‘ ๊ฐ€์ง€๋กœ ๊ตฌ์„ฑ

    ๐Ÿ‘‰ ํ•ด์‹œํ•จ์ˆ˜ h
    ๐Ÿ‘‰ ํฌ๊ธฐ M์˜ ๋ฐฐ์—ด(ํ…Œ์ด๋ธ”์ด๋ผ ๋ถ€๋ฅธ๋‹ค.)
  • ์‚ฌ์ „์„ ํ•ด์‹œํ…Œ์ด๋ธ”๋กœ ๊ตฌํ˜„ํ•  ๋•Œ, ๋ชฉํ‘œ๋Š” ํ•ญ๋ชฉ(k,e)๋ฅผ ์ฒจ์ž i = h(k)์— ์ €์žฅํ•˜๋Š” ๊ฒƒ
  • ํ•ด์‹œํ•จ์ˆ˜(Hash Function)๋Š” ๋ณดํ†ต ๋‘ ํ•จ์ˆ˜์˜ ๋ณตํ•ฉ์ฒด๋กœ ๋ช…์„ธํ•œ๋‹ค.

    ๐Ÿ‘‰ ํ•ด์‹œ์ฝ”๋“œ๋งต(Hash code map) h1 : keys -> integers
    ๐Ÿ‘‰ ์••์ถ•๋งต(Compression map) h2 : integers -> [0...M-1]
  • ๋จผ์ € ํ•ด์‹œ์ฝ”๋“œ๋งต์„ ์ ์šฉํ•˜๊ณ , ๊ทธ ๊ฒฐ๊ณผ์— ์••์ถ•๋งต์„ ์ ์šฉํ•œ๋‹ค. ์ฆ‰,

    ๐Ÿ‘‰ h(k) = h2(h1(k))
  • ์ข‹์€ ํ•ด์‹œํ•จ์ˆ˜๊ฐ€ ๋˜๊ธฐ ์œ„ํ•œ ์กฐ๊ฑด

    ๐Ÿ‘‰ ํ‚ค๋“ค์„ ์™ธ๊ฒฌ์ƒ ๋ฌด์ž‘์œ„ํ•˜๊ฒŒ(Random) ๋ถ„์‚ฐ์‹œ์ผœ์•ผ ํ•œ๋‹ค.
    ๐Ÿ‘‰ ๊ณ„์‚ฐ์ด ๋น ๋ฅด๊ณ  ์‰ฌ์›Œ์•ผ ํ•œ๋‹ค ( ๊ฐ€๋Šฅํ•˜๋ฉด ์ƒ์ˆ˜์‹œ๊ฐ„ )

ํ•ด์‹œํ•จ์ˆ˜ ์˜ˆ 

 

๐Ÿ“ข  ์••์ถ•๋งต

  • ๋‚˜๋ˆ„๊ธฐ(Division) (๋ณดํ†ต์‚ฌ์šฉ ๋ฐฉ์‹)

    ๐Ÿ‘‰ h2(k) = |k| % M
    ๐Ÿ‘‰ ํ•ด์‹œํ…Œ์ด๋ธ”์˜ ํฌ๊ธฐ M์€ ์ผ๋ฐ˜์ ์œผ๋กœ ์†Œ์ˆ˜(Prime)๋กœ ์„ ํƒ
  • ์Šนํ•ฉ์ œ(MAD, Multiply Add and Divide)

    ๐Ÿ‘‰ h2(k) = |ak + b| % M
    ๐Ÿ‘‰ a์™€ b๋Š” ์Œ์ด ์•„๋‹Œ ์ •์ˆ˜๋กœ์„œ, a % M != 0, ๊ทธ๋ ‡์ง€ ์•Š์œผ๋ฉด, ๋ชจ๋“  ์ •์ˆ˜๊ฐ€ ๋™์ผํ•œ ๊ฐ’ b๋กœ ๋งคํ•‘๋จ

 

๐Ÿ“ข  ํ•ด์‹œ์ฝ”๋“œ๋งต

  • ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ(Memory address)

    ๐Ÿ‘‰ ํ‚ค ๊ฐœ์ฒด์˜ ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๋ฅผ ์ •์ˆ˜๋กœ ์žฌํ•ด์„( ๋ชจ๋“  Java๊ฐ์ฒด๋“ค์˜ ๊ธฐ๋ณธ ํ•ด์‹œ์ฝ”๋“œ๋‹ค. )
    ๐Ÿ‘‰ ์ผ๋ฐ˜์ ์œผ๋กœ ๋งŒ์กฑ์Šค๋Ÿฌ์šฐ๋‚˜ ์ˆ˜์น˜ ๋˜๋Š” ๋ฌธ์ž์—ด ํ‚ค์—๋Š” ์ ์šฉ ๊ณค๋ž€
  • ์ •์ˆ˜ ์บ์ŠคํŠธ(Integer case)

    ๐Ÿ‘‰ ํ‚ค์˜ ๋น„ํŠธ๊ฐ’์„ ์ •์ˆ˜๋กœ ์žฌํ•ด์„
    ๐Ÿ‘‰ ์ •์ˆ˜ํ˜•์— ํ• ๋‹น๋œ ๋น„ํŠธ ์ˆ˜๋ฅผ ์ดˆ๊ณผํ•˜์ง€ ์•Š๋Š” ๊ธธ์ด์˜ ํ‚ค์—๋Š” ์ ๋‹น ( Java์˜ byte, short, int, float )
  • ์š”์†Œํ•ฉ(Component sum)

    ๐Ÿ‘‰ ํ‚ค์˜ ๋น„ํŠธ๋“ค์„ ๊ณ ์ •๊ธธ์ด(16 or 32bit)์˜ ์š”์†Œ๋“ค๋กœ ๋ถ„ํ• ํ•œ ํ›„ ๊ฐ ใ…Š ํ•ฉํ•œ๋‹ค(overflow๋Š” ๋ฌด์‹œํ•œ๋‹ค.)
    ๐Ÿ‘‰ ์ •์ˆ˜ํ˜•์— ํ• ๋‹น๋œ ๋น„ํŠธ ์ˆ˜ ์ด์ƒ์˜ ๊ณ ์ •๊ธธ์ด์˜ ์ˆ˜์น˜ ํ‚ค์— ์ ๋‹น ( ์˜ˆ : Java์˜ long, double )
    ๐Ÿ‘‰ ๋ฌธ์ž์˜ ์ˆœ์„œ์— ์˜๋ฏธ๊ฐ€ ์žˆ๋Š” ๋ฌธ์ž์—ด ํ‚ค์—๋Š” ๋ถ€์ ๋‹น ( ์˜ˆ: temp01-temp10, stop-tops-spot-pots )
  • ๋‹คํ•ญ ๋ˆ„์ (Ploynomial accumulation)

    ๐Ÿ‘‰ ์š”์†Œํ•ฉ๊ณผ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ, ํ‚ค์˜ ๋น„ํŠธ๋“ค์„ ๊ณ ์ •๊ธธ์ด(8,16,32bit)์˜ ์š”์†Œ๋“ค๋กœ ๋ถ„ํ•  ( a(0),a(1),...,a(N-1) )
    ๐Ÿ‘‰ ๊ณ ์ •๊ฐ’ z๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๊ฐ ์š”์†Œ์˜ ์œ„์น˜์— ๋”ฐ๋ฅธ ๋ณ„๋„ ๊ณ„์‚ฐ์„ ๋ถ€๊ณผํ•œ ๋‹คํ•ญ์‹ p(z)๋ฅผ ๊ณ„์‚ฐ (overflow ๋ฌด์‹œ)
    ๐Ÿ‘‰ p(z) = a(0) + a(1) * z + a(2) * z^2 + .... + a(N-1) * z ^ (N-1)
    ๐Ÿ‘‰ ๋ฌธ์ž์—ด์— ํŠนํžˆ ์ ๋‹น ( ์˜ˆ : ๊ณ ์ •๊ฐ’ z = 33์„ ์„ ํƒํ•  ๊ฒฝ์šฐ, 50,000๊ฐœ์˜ ์˜๋‹จ์–ด์— ๋Œ€ํ•ด ๋‹จ์ง€ 6ํšŒ ์ถฉ๋Œ๋งŒ ๋ฐœ์ƒ

 

๐Ÿ“ข  ์ถฉ๋Œํ•ด์ œ (์ค‘์š” !!)

  • ์ถฉ๋Œ(Collision) : ๋‘ ๊ฐœ ์ด์ƒ์˜ ์›์†Œ๋“ค์ด ๋™์ผํ•œ ์…€๋กœ ๋งคํ•‘๋˜๋Š” ๊ฒƒ
  • ์ฆ‰, ์ƒ์ดํ•œ ํ‚ค, k1๊ณผ k2์— ๋Œ€ํ•ด h(k1) = h(k2)๋ฉด "์ถฉ๋Œ์ด ์ผ์–ด๋‚ฌ๋‹ค."๊ณ  ๋งํ•œ๋‹ค.
  • ์ถฉ๋Œ ํ•ด๊ฒฐ(Collision resolution)์„ ์œ„ํ•œ ์ผ๊ด€๋œ ์ „๋žต์ด ํ•„์š”ํ•˜๋‹ค.

    ๐Ÿ‘‰ ๋ถ„๋ฆฌ์—ฐ์‡„๋ฒ•(Separate Chaining)
    ๐Ÿ‘‰ ์„ ํ˜•์กฐ์‚ฌ๋ฒ•(Linear Probing)
    ๐Ÿ‘‰ 2์ฐจ ์กฐ์‚ฌ๋ฒ•(Quadratic Probing)
    ๐Ÿ‘‰ ์ด์ค‘ํ•ด์‹ฑ(Double Hashing)

ํ•ด์‹œ ์ถฉ๋Œ(Hash Collision)

 

๐Ÿ“ข  ๋ถ„๋ฆฌ์—ฐ์‡„๋ฒ•

  • ๋ถ„๋ฆฌ์—ฐ์‡„๋ฒ•(Separate Chaining), ์—ฐ์‡„๋ฒ• : ๊ฐ ๋ฒ„์ผ“ A[i]๋Š” ๋ฆฌ์ŠคํŠธ L(i)์— ๋Œ€ํ•œ ์ฐธ์กฐ๋ฅผ ์ €์žฅ ( L(i)๋Š” ๋ฆฌ์ŠคํŠธ )

    ๐Ÿ‘‰ ํ•ด์‹œํ•จ์ˆ˜๊ฐ€ ๋ฒ„์ผ“ A[i]๋กœ ๋งคํ•‘ํ•œ ๋ชจ๋“  ํ•ญ๋ชฉ๋“ค์„ ์ €์žฅ
    ๐Ÿ‘‰ ๋ฌด์ˆœ๋ฆฌ์ŠคํŠธ๊ฐ€ ๋˜๋Š” ๊ธฐ๋กํŒŒ์ผ ๋ฐฉ์‹์„ ์‚ฌ์šฉํ•˜์—ฌ ๊ตฌํ˜„๋œ ๋ฏธ๋‹ˆ ์‚ฌ์ „์ด๋ผ ๋ณผ ์ˆ˜ ์žˆ๋‹ค.
  • ์žฅ๋‹จ์  : ๋‹จ์ˆœํ•˜๊ณ  ๋น ๋ฅด๋‹ค๋Š” ์žฅ์ ์ด ์žˆ์œผ๋‚˜ ํ…Œ์ด๋ธ” ์™ธ๋ถ€์— ์ถ”๊ฐ€์ ์ธ ์ €์žฅ๊ณต๊ฐ„์„ ์š”๊ตฌ

๋ถ„๋ฆฌ์—ฐ์‡„๋ฒ•(Separate Chaining)

  • ์˜ˆ์‹œ

    ๐Ÿ‘‰ h(k) = k % M
    ๐Ÿ‘‰ ํ‚ค : 25,13,16,15,7,28,31,20,1  (    = ์ถฉ๋Œ ์ผ์–ด๋‚œ ํ‚ค๊ฐ’ )
    ๐Ÿ‘‰ ๋ฆฌ์Šค์— ์ถ”๊ฐ€๋˜๋Š” ํ•ญ๋ชฉ๋“ค์˜ ์œ„์น˜๋Š”, ๋ฆฌ์ŠคํŠธ์˜ ๋งจ ์•ž์— ์‚ฝ์ž…ํ•˜๋Š” ๊ฒƒ์ด ์œ ๋ฆฌํ•˜๋‹ค. (๋ฆฌ์ŠคํŠธ์˜ tail ํฌ์ธํ„ฐ ์—†๋Š”๊ฒฝ์šฐ)

๋ถ„ํ• ์—ฐ์‡„๋ฒ• ์˜ˆ์‹œ

 

๐Ÿ“ข  ๊ฐœ๋ฐฉ์ฃผ์†Œ๋ฒ• ( ์„ ํ˜•์กฐ์‚ฌ๋ฒ• )

  • ๊ฐœ๋ฐฉ์ฃผ์†Œ๋ฒ•(Open Addresssing) : ์ถฉ๋Œ ํ•ญ๋ชฉ์„ ํ…Œ์ด๋ธ”์˜ ๋‹ค๋ฅธ ์…€์— ์ €์žฅ
  • ์žฅ๋‹จ์  : ๋ถ„๋ฆฌ์—ฐ์‡„๋ฒ•์— ๋น„ํ•ด ๊ณต๊ฐ„ ์‚ฌ์šฉ์„ ์ ˆ์•ฝํ•˜์ง€๋งŒ, ์‚ญ์ œ๊ฐ€ ์–ด๋ ต๋‹ค๋Š” ๊ฒƒ๊ณผ ์‚ฌ์ „ ํ•ญ๋ชฉ๋“ค์ด ์—ฐ์ด์–ด ๊ตฐ์ง‘ํ™”

๊ฐœ๋ฐฉ ์ฃผ์†Œ๋ฒ•

  • ์„ ํ˜•์กฐ์‚ฌ๋ฒ•(Linear Probing) : ์ถฉ๋Œ ํ•ญ๋ชฉ์„ (์›ํ˜•์œผ๋กœ)๋ฐ”๋กœ ๋‹ค์Œ์˜ ๋น„์–ด์žˆ๋Š” ํ…Œ์ด๋ธ” ์…€์— ์ €์žฅํ•จ์œผ๋กœ์จ ์ถฉ๋Œ์„ ์ฒ˜๋ฆฌ
  • ์ฆ‰, ๋‹ค์Œ ์ˆœ์„œ์— ์˜ํ•ด ๋ฒ„์ผ“์„ ์กฐ์‚ฌํ•œ๋‹ค.

    ๐Ÿ‘‰ A[ (h(k) + f(i)) % M ], f(i) = i, i = 0,1,2,...
  • ๊ฒ€์‚ฌ๋˜๋Š” ๊ฐ ํ…Œ์ด๋ธ” ์…€์€ ์กฐ์‚ฌ(Probe)๋ผ ๋ถˆ๋ฆฐ๋‹ค.
  • ์ถฉ๋Œ ํ•ญ๋ชฉ๋“ค์€ ๊ตฐ์ง‘ํ™”ํ•˜๋ฉฐ, ์ดํ›„์˜ ์ถฉ๋Œ์— ์˜ํ•ด ๋”์šฑ ๊ธด ์กฐ์‚ฌ์—ด(Probe sequence)๋กœ ๊ตฐ์ง‘๋จ = "1์ฐจ ๊ตฐ์ง‘ํ™”"
  • ์˜ˆ์‹œ

    ๐Ÿ‘‰ h(k) = k % M
    ๐Ÿ‘‰ ํ‚ค : 25,13,16,15,7,28,31,20,1,38      = ์ถฉ๋Œ ํ‚ค )

์„ ํ˜•์กฐ์‚ฌ๋ฒ• ์˜ˆ์‹œ

 

๐Ÿ“ข  ๊ฐœ๋ฐฉ ์ฃผ์†Œ๋ฒ•( 2์ฐจ ์กฐ์‚ฌ๋ฒ• )

  • 2์ฐจ ์กฐ์‚ฌ๋ฒ•(Quadratic Probing) : ๋‹ค์Œ ์ˆœ์„œ์— ์˜ํ•ด ๋ฒ„์ผ“์„ ์กฐ์‚ฌ

    ๐Ÿ‘‰ A[ (h(k) + f(i) % M ], f(i) = i^2, i = 0,1,2,...
  • ํ•ด์‹œ ๊ฐ’์ด ๋™์ผํ•œ ํ‚ค๋“ค์€ ๋™์ผํ•œ ์กฐ์‚ฌ๋ฅผ ์ˆ˜๋ฐ˜ํ•œ๋‹ค.
  • 1์ฐจ ๊ตฐ์ง‘ํ™”๋ฅผ ํ”ผํ•˜์ง€๋งŒ, ๋‚˜๋ฆ„๋Œ€๋กœ์˜ ๊ตฐ์ง‘์„ ํ˜•์„ฑ ํ•  ์ˆ˜ ์žˆ๋‹ค. = "2์ฐจ ๊ตฐ์ง‘ํ™”"
  • M์ด ์†Œ์ˆ˜๊ฐ€ ์•„๋‹ˆ๊ฑฐ๋‚˜ ๋ฒ„์ผ“ ๋ฐฐ์—ด์ด ๋ฐ˜ ์ด์ƒ ์ฐจ๋ฉด, ๋น„์–ด ์žˆ๋Š” ๋ฒ„์ผ“์ด ๋‚จ์•„ ์žˆ๋”๋ผ๋„ ์ฐพ์ง€ ๋ชปํ•  ์ˆ˜ ์žˆ๋‹ค. ( ๋‹จ์  )
  • ์˜ˆ์‹œ

    ๐Ÿ‘‰ h(k) = k % M, f(i) = i^2
    ๐Ÿ‘‰ ํ‚ค : 25,13,16,15,7,28,31,20,1,38

2์ฐจ ์กฐ์‚ฌ๋ฒ• ์˜ˆ์‹œ

 

๐Ÿ“ข  ์ด์ค‘ํ•ด์‹ฑ

  • ์ด์ค‘ํ•ด์‹ฑ(Double Hashing) : ๋‘ ๋ฒˆ์งธ์˜ ํ•ด์‹œํ•จ์ˆ˜ h`๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋‹ค์Œ ์ˆœ์„œ์— ์˜ํ•ด ๋ฒ„์ผ“์„ ์กฐ์‚ฌ

    ๐Ÿ‘‰ A[ (h(k) + f(i)) % M ], f(i) = i * h`(k), i = 0,1,2,....
  • ๋™์ผํ•œ ํ•ด์‹œ๊ฐ’์„ ๊ฐ€์ง€๋Š” ํ‚ค๋“ค๋„ ์ƒ์ดํ•œ ์กฐ์‚ฌ๋ฅผ ์ˆ˜๋ฐ˜ํ•  ์ˆ˜ ์žˆ๊ธฐ ๋•Œ๋ฌธ์— ๊ตฐ์ง‘ํ™”๋ฅผ ์ตœ์†Œํ™”ํ•œ๋‹ค.
  • h`๋Š” ๊ณ„์‚ฐ ๊ฒฐ๊ณผ๊ฐ€ 0์ด ๋˜๋ฉด ์•ˆ๋œ๋‹ค. ๐Ÿ‘‰ ( 0์ด ๋˜๋ฉด, f(i)๋Š” ๊ฒฐ๊ณผ์ ์œผ๋กœ 0๋งŒ ๋˜๊ฒ ์ฃ  ? ๊ทธ๋Ÿผ ํ•œ์ž๋งŒ ๊ณ„์† ํ•ด์‹ฑ์ถฉ๋Œ )
  • ์ตœ์„ ์˜ ๊ฒฐ๊ณผ๋ฅผ ์œ„ํ•ด, h`(k)์™€ M์€ ์„œ๋กœ์†Œ(Relative Prime)์—ฌ์•ผ ํ•œ๋‹ค.

    ๐Ÿ‘‰ d(1)*M = d(2)*h`(k)์ด๋ฉด, d(2) ๊ฐœ์˜ ์กฐ์‚ฌ๋งŒ ์‹œ๋„ํ•œ๋‹ค. ์ฆ‰, ๋ฒ„์ผ“๋“ค ์ค‘ d(2)/M๋งŒ ๊ฒ€์‚ฌ
    ๐Ÿ‘‰ h`(k) = q - (k % q) ๋˜๋Š” 1 + (k % q)๋ฅผ ์‚ฌ์šฉ ( ๋‹จ, q < M์€ ์†Œ์ˆ˜๋ฉฐ M ์—ญ์‹œ ์†Œ์ˆ˜์ผ ๊ฒฝ์šฐ )
    ๐Ÿ‘‰ ํ•œ ๋งˆ๋””๋กœ ์œ„์— ๋‘ ์กฐ๊ฑด์„ ๋งŒ์กฑ์‹œํ‚ค๋Š”, ํ•ด์‹œํ•จ์ˆ˜๋ฅผ ์ ์šฉํ•˜๋ฉด, ๊ตฐ์ง‘ํ™”๋ฅผ ์ตœ์†Œํ™”ํ•˜๋ฉด์„œ, ์ตœ์†Œํ™”๋กœ ์‹คํ–‰๊ฐ€๋Šฅ
  • ์˜ˆ์‹œ

    ๐Ÿ‘‰ h(k) = k % M, h`(k) = 11 - (k % 11),  ( ์ด๋•Œ q = 11์ด๊ณ , 11์€ ์„œ๋กœ์†Œ์ด๋‹ค. )
    ๐Ÿ‘‰ ํ‚ค : 25,13,16,15,7,28,31,20,1,38      = ์ถฉ๋Œ ํ‚ค )

์ด์ค‘ํ•ด์‹ฑ ์˜ˆ์‹œ

  • ๊ฐœ๋ฐฉ์ฃผ์†Œ๋ฒ•( ์„ ํ˜•์กฐ์‚ฌ๋ฒ•, 2์ฐจ์กฐ์‚ฌ๋ฒ• ), ์ด์ค‘ํ•ด์‹ฑ ์•Œ๊ณ ๋ฆฌ์ฆ˜
Alg findElement(k)
	input bucket array A[0...M-1], hash function h, key k
    output element with key k

v <- h(k)			// h(k) = ํ•ด์‹œํ•จ์ˆ˜๋Š” ๋ณดํ†ต ์ฃผ์–ด์ง„๋‹ค.
i <- 0
while(i < M)
	b <- getNextBucket(v,i)
    if(isEmpty(A[b])
		return NoSuchKey
	elseif(k == key(A[b])
		return element(A[b])
	else
    	i <- i + 1
return NoSuchKey

=========================================================
Alg insertItem(k,e)

v <- h(k)
i <- 0
while(i < M)
	b <- getNextBucket(v,i)
    if(isEmpty(A[b]))
    	Set bucket A[b] to (k,e)
        return
	else
    	i <- i + 1
overflowException()
return
Alg getNextBucket(v,i)		// ์„ ํ˜•์กฐ์‚ฌ๋ฒ•

return (v + i) % M

==========================================
Alg getNextBucket(v,i)		// 2์ฐจ์กฐ์‚ฌ๋ฒ•

return (v + i^2) % M
==========================================
Alg getNextBucket(v,i)		// ์ด์ค‘ํ•ด์‹ฑ

return (v + i * h`(k)) % M




===========================================
Alg initBucketArray()		// ๋ฒ„ํ‚ท์ดˆ๊ธฐํ™”(์˜ˆ์‹œ)
	input bucket array A[0...M-1]
    output bucket array A[0...M-1] initialized with null buckets

for i <- 0 to M-1
	A[i].empty <- 1			// Set empty
return
===========================================
Alg isEmpty(b)
	input bucket b
    output boolean

return b.empty

 

๐Ÿ“ข  ์ ์žฌ์œจ

  • ํ•ด์‹œํ…Œ์ด๋ธ”์˜ ์ ์žฌ์œจ(Load factor), a = N/M ( N์€ ํ‚ค ์ˆ˜, M์€ ๋ฒ„์ผ“๋ฐฐ์—ด ํฌ๊ธฐ )

    ๐Ÿ‘‰ ์ฆ‰, ์ข‹์€ ํ•ด์‹œํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•  ๊ฒฝ์šฐ์˜ ๊ฐ ๋ฒ„์ผ“์˜ ๊ธฐ๋Œ€ํฌ๊ธฐ
  • ์ ์žฌ์œจ์€ ๋‚ฎ๊ฒŒ ์œ ์ง€๋˜์–ด์•ผ ํ•œ๋‹ค ( ๊ฐ€๋Šฅํ•˜๋ฉด 1 ์•„๋ž˜๋กœ, ์ฆ‰ a = N/M < 1 ๋˜๋„๋ก)
  • ์ข‹์€ ํ•ด์‹œํ•จ์ˆ˜๊ฐ€ ์ฃผ์–ด์กŒ๋‹ค๋ฉด, ํƒ์ƒ‰,์‚ฝ์ž…,์‚ญ์ œ ๊ฐ ์ž‘์—…์˜ ๊ธฐ๋Œ€ ์‹คํ–‰์‹œ๊ฐ„ = O(a)
  • ๋ถ„๋ฆฌ์—ฐ์‡„๋ฒ•

    ๐Ÿ‘‰ a > 1 ์ด๋ฉด, ์ž‘๋™์€ ํ•˜์ง€๋งŒ ๋น„ํšจ์šธ์ 
    ๐Ÿ‘‰ a < 1 ์ด๋ฉด, O(a) = O(1)์˜ ๊ธฐ๋Œ€์‹คํ–‰์‹œ๊ฐ„ ์„ฑ์ทจ ๊ฐ€๋Šฅ
  • ๊ฐœ๋ฐฉ์ฃผ์†Œ๋ฒ• ( ์„ ํ˜•์กฐ์‚ฌ๋ฒ•, 2์ฐจ์กฐ์‚ฌ๋ฒ• )

    ๐Ÿ‘‰ ํ•ญ์ƒ a < 1
    ๐Ÿ‘‰ a > 0.5 ์ด๋ฉด, ์„ ํ˜• ๋ฐ 2์ฐจ ์กฐ์‚ฌ์ธ ๊ฒฝ์šฐ ๊ตฐ์ง‘ํ™” ๊ฐ€๋Šฅ์„ฑ ๋†ํ›„ํ•˜๋‹ค.
    ๐Ÿ‘‰ a <= 0.5 ์ด๋ฉด, O(a) = O(1) ๊ธฐ๋Œ€์‹คํ–‰์‹œ๊ฐ„

 

๐Ÿ“ข  ํ•ด์‹ฑ์˜ ์„ฑ๋Šฅ

  • ํ•ด์‹œํ…Œ์ด๋ธ”์— ๋Œ€ํ•œ ํƒ์ƒ‰,์‚ฝ์ž…,์‚ญ์ œ

    ๐Ÿ‘‰ (์ตœ์•…์˜ ๊ฒฝ์šฐ) O(N) ์‹œ๊ฐ„ ์†Œ์š”
  • ์ตœ์•…์˜ ๊ฒฝ์šฐ๋ž€ : ์‚ฌ์ „์— ์‚ฝ์ž…๋œ ๋ชจ๋“  ํ‚ค๊ฐ€ ์ถฉ๋Œํ•  ๊ฒฝ์šฐ
  • ์ ์žฌ์œจ(Load factor) : a = N/M์€ ํ•ด์‹œํ…Œ์ด๋ธ”์˜ ์„ฑ๋Šฅ์„ ์ขŒ์šฐํ•œ๋‹ค.
  • ํ•ด์‹œ๊ฐ’๋“ค์€ ํ”ํžˆ, ๋‚œ์ˆ˜(Random numbers)์™€ ๊ฐ™๋‹ค๊ณ  ๊ฐ€์ •ํ•˜๋ฉด, ๊ฐœ๋ฐฉ์ฃผ์†Œ๋ฒ•(์„ ํ˜•์กฐ์‚ฌ๋ฒ• or 2์ฐจ์กฐ์‚ฌ๋ฒ•)์— ์˜ํ•œ
    ์‚ฝ์ž…์„ ์œ„ํ•œ ๊ธฐ๋Œ€ ์กฐ์‚ฌํšŸ์ˆ˜๋Š” 1/(1 - a)๋ผ๊ณ  ์•Œ๋ ค์ ธ ์žˆ๋‹ค.
  • ํ•ด์‹œํ…Œ์ด๋ธ”์—์„œ ๋ชจ๋“  ์‚ฌ์ „ ADT ์ž‘์—…๋“ค์˜ ๊ธฐ๋Œ€์‹คํ–‰์‹œ๊ฐ„ : O(1)
  • ์‹ค์ „์—์„œ, ์ ์žฌ์œจ์ด 1(์ฆ‰, 100%)์— ๊ฐ€๊น์ง€๋งŒ ์•Š๋‹ค๋ฉด, ํ•ด์‹ฑ์€ ๋งค์šฐ ๋น ๋ฅธ ๊ฒƒ์ด๋‹ค.
  • ์‘์šฉ๋ถ„์•ผ

    ๐Ÿ‘‰ ์†Œ๊ทœ๋ชจ ๋ฐ์ดํ…Œ๋ฒ ์ด์Šค ( ์ธ๋ฑ์Šค )
    ๐Ÿ‘‰ ์ปดํŒŒ์ผ๋Ÿฌ
    ๐Ÿ‘‰ ๋ธŒ๋ผ์šฐ์ € ์บ์‹œ
728x90
๋ฐ˜์‘ํ˜•