2022. 6. 26. 22:09ใ๐คฟ ์จ์ฐธ๊ณ Deep Dive
์๋ฃ๊ตฌ์กฐ๋ ?
ํจ์จ์ ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ๊ด๋ฆฌํ๊ณ , ํ์, ์ ์ฅ, ์์ , ์ญ์ ํ ์ ์๋ ๋ฐ์ดํฐ ์งํฉ์ ์๋ฏธ
Q. Array ๋ ์ด๋ค ์๋ฃ๊ตฌ์กฐ์ธ๊ฐ?
A. ๋ฐ์ดํฐ๋ฅผ ๋ฉ๋ชจ๋ฆฌ์์ ์ฐ์์ ์ด๋ฉฐ ์์ฐจ์ ์ผ๋ก ๋ฏธ๋ฆฌ ํ ๋น๋ ํฌ๊ธฐ๋งํผ ์ ์ฅํ๋ ์๋ฃ๊ตฌ์กฐ.
-> point 1. ๋ฉ๋ชจ๋ฆฌ ์์ ์ฐ์์ ์ผ๋ก ์ ์ฅ๋๋ค.
-> point 2. ๋ฏธ๋ฆฌ ํ ๋น๋ ์ ์ฅ ๊ณต๊ฐ = ๊ณ ์ ์ ์ธ ์ ์ฅ๊ณต๊ฐ
์ฅ์ : ์กฐํ์ append ๊ฐ ๋น ๋ฅด๋ค.
๋จ์ : fixed Size ํน์ฑ์ ๋ฏธ๋ฆฌ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋น ๋ฐ์์ผ ํ๋๋ฐ, ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น๋ ์ถ๊ฐ์ ์ธ overhead ๊ฐ ๋ฐ์ํ ์ ์๋ค.
Q. array ์ ๋ฏธ๋ฆฌ ๊ณ ์ ๋ ํฌ๊ธฐ๋ณด๋ค ๋ ๋ง์ data ๋ฅผ ์ ์ฅํ๊ฒ ๋๋ฉด ์ด๋ป๊ฒ ํด๊ฒฐํ๋?
A. ๊ธฐ์กด size ๋ณด๋ค ๋ ํฐ Array ๋ฅผ ์์ฑํ์ฌ ๋ฐ์ดํฐ๋ฅผ ์ฎ๊ฒจ ํ ๋นํ๋ค.
์์ ๊ฐ์ ๋ฐฉ์์ผ๋ก, ๋์ ์ผ๋ก ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ์กฐ์ ํ๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ Dynamic Array ๋ผ๊ณ ํ๋ค.
Q. Dynamic Array ๋?
A. ์ ์ฅ๊ณต๊ฐ์ด ๊ฐ๋์ฐจ๋ฉด, ๋์ ์ผ๋ก resize ํ์ฌ size ๋ฅผ ์กฐ์ ํ๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์๋ฏธํ๋ค.
-> resize ๋ฐฉ์ - Doubling : ๊ธฐ์กด ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ด๊ณผํ์ฌ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ฒ ๋๋ฉด, size ๋ฅผ 2๋ฐฐ ๋๋ฆฐ ๋ฐฐ์ด์ ์ ์ธํ๊ณ , ๊ทธ๊ณณ์ผ๋ก ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ์ฎ๊ฒจ ๋์ด๋ ํฌ๊ธฐ์ size ๋ฅผ ๊ฐ์ง ๋ฐฐ์ด์ด ๋๋ค.
Q. Array ์ ์๊ฐ๋ณต์ก๋๋ ์ด๋ป๊ฒ ๋๋๊ฐ?
A.
- append() ํ ๋, ํ์์์ O(1) ์ด์ง๋ง, Resize ๊ฐ ๋ฐ์ํ๋ค๋ฉด, ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ์๋ก์ด array ์ ์ฎ๊ฒจ์ผ ํ๊ธฐ ๋๋ฌธ์ O(n) ์ ์๊ฐ๋ณต์ก๋๊ฐ ๊ฑธ๋ฆฐ๋ค. ํ๊ท ์ ์ผ๋ก๋ O(1) ์ด๋ผ ๋ณผ ์ ์๋ค.
- ๋ฐ์ดํฐ ์กฐํ์, ๋ฐฐ์ด์ ์ธ๋ฑ์ค๋ก ๊ณง๋ฐ๋ก ์กฐํํ๊ธฐ์ O(1) ์ ์๊ฐ๋ณต์ก๋๊ฐ ๊ฑธ๋ฆฐ๋ค.
Q. LinkedList ๋?
A. Node ๋ผ๋ ๊ตฌ์กฐ์ฒด๋ก ์ด๋ฃจ์ด์ ธ, ํ๋์ Node ์ ๋ฐ์ดํฐ ๊ฐ๊ณผ ๋ค์ Node ์ Address ๋ฅผ ์ ์ฅํ๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์๋ฏธํ๋ค.
- Array ์ ๋ฌ๋ฆฌ ๋ฌผ๋ฆฌ์ ๋ฉ๋ชจ๋ฆฌ ์์๋ ๋น์ฐ์์
์ผ๋ก ์ ์ฅ๋์ง๋ง, Linked List ๋ฅผ ๊ตฌ์ฑํ๋ ๊ฐ๊ฐ์ Node ๊ฐ ๋ค์ Node ์ address ๋ฅผ ๊ฐ๋ฅดํด์ผ๋ก ๋
ผ๋ฆฌ์ ์ธ ์ฐ์์ฑ
์ ๊ฐ์ง๋ค.
- ๊ณ ์ ํฌ๊ธฐ์ Array ์ ๋ฌ๋ฆฌ, Linked List ๋ ๋ฐ์ดํฐ๊ฐ ์ถ๊ฐ๋๋ ์์ ์ ๋ฉ๋ชจ๋ฆฌ๊ฐ ํ ๋น๋๊ธฐ์, ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ ํจ์จ์ ์ผ๋ก ์ฌ์ฉํ ์ ์๋ค.
Q. ์ด๋ ์ํฉ์์ Array ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด Linked List ๋ณด๋ค ๋์ ์ ํ์ธ๊ฐ?
A.
- ์ฃผ๋ก ์กฐํ ์์ ์ ์์ฃผํ ๋
- ๋ฐ์ดํฐ๋ฅผ ๋ฐ๋ณต๋ฌธ์ ํตํด ๋น ๋ฅด๊ฒ ์ํํ ๋
- ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ ๊ฒ ์ฐ๋๊ฒ ์ค์ํ ์ํฉ์ผ ๋. ๊ณ ์ ํฌ๊ธฐ ๋ฐฉ์์ด์ง๋ง, Linked List ๋ณด๋จ array ๊ฐ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ ๊ฒ ์ฐจ์งํ๊ธฐ ๋๋ฌธ์, ๋ฏธ๋ฆฌ ๋ฐ์ดํฐ์ ์ฌ์ด์ฆ๋ฅผ ์๊ณ ์๋ค๋ฉด Array ๊ฐ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ ํจ์จ์ ์ผ๋ก ์ฌ์ฉํ๋ค. Linked List ๋ Node ๋ก ์ด๋ฃจ์ด์ก๊ธฐ์ ์๋ ๋ฉ๋ชจ๋ฆฌ ํ ๋น๋์ด ํฌ๋ค.
Q. Array ์ LinkedList ๋น๊ตํด์ ์ค๋ช ํด๋ณด๋ผ
A. ์ฐ์ ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ ์ฐจ์ด๋ก ์ธํ ์ฐจ์ด์ ์ด ์กด์ฌํ๋ค.
- 1. Operation ๊ตฌํ ๋ฐฉ๋ฒ์ด ๋ค๋ฅด๊ณ ,
- 2. ์๊ฐ ๋ณต์ก๋๋ ๋ค๋ฅด๋ค.
- Linked List
- O(N) : access / search <- ๋ฉ๋ชจ๋ฆฌ์ ๋น ์ฐ์์ ์ผ๋ก ์ ์ฅ๋ผ ์๊ธฐ ๋๋ฌธ.
- O(1) : insertion / delete <- ๋ง์ฐฌ๊ฐ์ง๋ก ๋ฉ๋ชจ๋ฆฌ์ ๋น ์ฐ์์ ์ผ๋ก ์ ์ฅ๋ผ ์๊ธฐ ๋๋ฌธ์, ์ฝ์ ๊ณผ ์ญ์ ๋ ์ฝ๋ค.
- 3. ๋ฉ๋ชจ๋ฆฌ ํ์ฉ๋์์๋ ์ฐจ์ด๊ฐ ์๋ค.
- Array๋ ์ฐ์ ์ฐ์์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ด๋ผ๋ ํน์ฑ์์ ๋ฐ์ดํฐ ์ ๊ทผ๊ณผ append ๊ฐ ๋น ๋ฅด์ง๋ง, ๊ณ ์ ํฌ๊ธฐ ํ ๋น์ด๊ธฐ์ ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น๋ผ๋ ๋จ์ ๋ ์กด์ฌํ๋ค.
- Linked List ๋ runtime ์ค์๋ size ๋ฅผ ๋๋ฆฌ๊ฑฐ๋ ์ค์ผ ์ ์๋ค. ๊ทธ๋์ array ์ ๋ฌ๋ฆฌ memory allocation ๊ด์ ์์๋ ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น๊ฐ ์๋ค. ํ์ง๋ง ๋น์ฐ์์ ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ๋ก ์ธํด ๋ฐ์ดํฐ ์ ๊ทผ๊ณผ ํ์์ด ๋น๊ต์ ๋๋ฆฌ๋ค.
Q. Array ์ LinkedList ์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ ์ธ์ ์ผ์ด๋๋ฉฐ, ๋ฉ๋ชจ๋ฆฌ์ ์ด๋ ์์ญ์ ํ ๋น๋ฐ๋?
A.
- Array ๋ ์ปดํ์ผ ๋จ๊ณ์์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ด ์ผ์ด๋๋ค. ์ด๋ฅผ static memory allocation ์ด๋ผ ๋ถ๋ฅด๋ฉฐ, Stack Memory ์์ญ์ ํ ๋น๋๋ค.
- LInked List ๋ ๋ฐํ์ ๋จ๊ณ์์ ์๋ก์ด node ๊ฐ ์ถ๊ฐ๋ ๋๋ง๋ค memory allocation ์ด ์ผ์ด๋๋ค. ์ด๋ฅผ dynamic memory allocation ์ด๋ผ ๋ถ๋ฅด๋ฉฐ, heap ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ํ ๋น๋๋ค.
Q. Queue ๋ ์ด๋ค ์๋ฃ๊ตฌ์กฐ์ธ๊ฐ?
A. ์ ์ ์ ์ถ ํ์์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ์๋ฃ๊ตฌ์กฐ !!
- ์๊ฐ๋ณต์ก๋
- Enqueue : ๋ฐ์ดํฐ ์ถ๊ฐ : O(1)
- Dequeue : ๋ฐ์ดํฐ ์ญ์ : O(1)
- ํ์ฉ ์์
- Cache ๊ตฌํ, Process ๊ด๋ฆฌ, BFS ๋ฑ
Q. Array Based Queue ์ List Based Queue ๋ฅผ ์ค๋ช ํด๋ฌ๋ผ
A.
- Array-Base ๋ circular queue ๋ก ๊ตฌํํ๋ ๊ฒ์ด ์ผ๋ฐ์ ์ด๋ค. ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํจ์จ์ ์ผ๋ก ์ฌ์ฉํ๊ธฐ ์ํจ์ธ๋ฐ, enqueue ๊ฐ ๊ณ์ ๋ฐ์์ fixed size ๋ฅผ ๋์ด์๋๋ผ๋, ์๊ฐ๋ณต์ก๋๋ O(1) ์ ์ ์งํ ์ ์๋ค.
- List-Base ๋ ๋ณดํต linked list ๋ก ๊ตฌํํ๋ค. enqueue ๋ ๋จ์ํ linked list ์์ append ๋ฅผ ํ๋๊ฒ์ผ๋ก ๊ตฌํ๋๊ณ , ์ด ๋ ์๊ฐ๋ณต์ก๋๋ O(1) ์ด ๋๋ค. dequeue ๋ ๋งจ ์์ ์์๋ฅผ ์ญ์ ํ๊ณ first head ๋ฅผ ๋ณ๊ฒฝํ๊ธฐ ๋๋ฌธ์ ์ญ์ O(1) ์ ์๊ฐ๋ณต์ก๋๊ฐ ๊ฑธ๋ฆฐ๋ค.
Q. Queue vs Priority Queue ๋ฅผ ๋น๊ตํ์ฌ ์ค๋ช ํด๋ณด๋ผ
A.
Queue ๋ ์๊ฐ์์์ ๋จผ์ ๋ค์ด๊ฐ ๋ฐ์ดํฐ๊ฐ ๋จผ์ ์ถ๋ ฅ๋๋ ์๋ฃ๊ตฌ์กฐ์ด๋ฉฐ,
Priority queue ๋ ๋ค์ด๊ฐ ์์์ ์๊ด์์ด, ์ฐ์ ์์๊ฐ ๋์ ๋ฐ์ดํฐ๊ฐ ๋จผ์ ์ถ๋ ฅ๋๋ค.
Q. Heap ์ ์ด๋ค ์๋ฃ๊ตฌ์กฐ์ธ๊ฐ?
A. Heap ์ ๊ทธ ์์ฒด๋ก ์ฐ์ ์์ ํ์ ๊ตฌํ๊ณผ ์ผ์นํ๋ค.
- Heap ์ ์์ ์ด์งํธ๋ฆฌ๋ก ์๋์ ์กฐ๊ฑด์ ๊ฐ์ง๋ค.
- 1) Max Heap : ๊ฐ ๋ ธ๋์ ์ ์ฅ๋ ๊ฐ์ child node ์ ๊ฐ๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๋ค.
- 2) Min Heap : ๊ฐ ๋ ธ๋์ ์ ์ฅ๋ ๊ฐ์ child node ์ ๊ฐ๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๋ค.
Q. Heap ์ ์ด๋ป๊ฒ ๊ตฌํํ ์ ์๋๊ฐ?
A. ๋ณดํต์ Tree ๋ linked list ๋ก ๊ตฌํํ์ง๋ง, Heap ์ ํธ๋ฆฌ์์๋ ๋ถ๊ตฌํ๊ณ Array ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๊ตฌํํ๋ค.
์๋ก์ด node ๋ฅผ heap ์ ๋ง์ง๋ง ์์น์ ์ถ๊ฐํด์ผํ๋ ํน์ง ๋๋ฌธ์ธ๋ฐ, array ๊ธฐ๋ฐ์ผ๋ก ๊ตฌํํด์ผ ๋ ์์ํ๊ธฐ ๋๋ฌธ์ด๋ค. ๋ง์ง๋ง ์์น์ ์ถ๊ฐํ๊ธด ํ์ง๋ง, swap ๊ณผ์ ์ ๊ฑฐ์ณ ์์ ์ ์์น๋ฅผ ์ฐพ์๊ฐ๋ค.
Q. Stack ์ ์ด๋ค ์๋ฃ๊ตฌ์กฐ์ธ๊ฐ?
A. ํ์ ์ ์ถ ํํ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ์๋ฃ๊ตฌ์กฐ.
- ์๊ฐ๋ณต์ก๋๋ push, pop ๋ชจ๋ O(1)
- ํ์ฉ ์์ : ํ์ ํ๊ธฐ๋ฒ ์ฐ์ฐ, ๊ดํธ ์ ํจ์ฑ ๊ฒ์ฌ, ๋ธ๋ผ์ฐ์ ๋ค๋ก๊ฐ๊ธฐ ๊ธฐ๋ฅ, DFS ๋ฑ
Q. BST(Binary Search Tree) ๋ ์ด๋ค ์๋ฃ๊ตฌ์กฐ์ธ๊ฐ?
A. ์ด์ง ํ์ ํธ๋ฆฌ๋ ์ ๋ ฌ๋ ํธ๋ฆฌ ๊ตฌ์กฐ๋ก, ์ด๋ค ๋ ธ๋์ left ์ ์์นํ๋ ๋ชจ๋ ๊ฐ์ ํด๋น ๋ ธ๋๋ณด๋ค ์์ ๊ฐ์ ๊ฐ์ง๋ฉฐ, right ์ ์์นํ ๊ฐ์ ํด๋น node ๋ณด๋ค ํฐ ๊ฐ์ ๊ฐ๋๋ค.
- BST ๋ ์ ์ฅ๊ณผ ๋์์ ์ ๋ ฌ์ ํ๋ ์๋ฃ๊ตฌ์กฐ๋ก, ์๋ก์ด Data ์ ์ฅ์ ์ผ์ ํ ๊ท์น์ ๋ฐ๋ผ ์ ์ฅํ๊ฒ ๋๋ค.
- ์๊ฐ ๋ณต์ก๋
- ๊ฒ์, ์ ์ฅ, ์ญ์ : O(logN) -> ํธ๋ฆฌ์ ๋์ด๊ฐ logN ์ด๊ธฐ ๋๋ฌธ
- worst case ์ผ ๋ : O(logN) -> ์ ํ ๊ตฌ์กฐ์ด๊ธฐ ๋๋ฌธ
Q. ์ด์ง ํ์ํธ๋ฆฌ์ ์๊ฐ๋ณต์ก๋๋ฅผ ๋งํด๋ฌ๋ผ.
A. ๊ฒ์๊ณผ ์ ์ฅ, ์ญ์ ์ ์๊ฐ๋ณต์ก๋๋ ๋ชจ๋ O(logN) ์ด๊ณ , Worst Case ๋ ํ์ชฝ์ผ๋ก ์น์ฐ์น Tree ๊ฐ ๋์ ๋ O(N) ์ด ๋๋ค.
Q. ์ด์ง ํธ๋ฆฌ๋ ์ด๋ค ์๋ฃ๊ตฌ์กฐ์ธ๊ฐ?
A. ๋ชจ๋ Nodes ์ Child nodes ๊ฐฏ์๊ฐ 2 ์ดํ์ธ ํธ๋ฆฌ.
Q. ์ด์ง ํธ๋ฆฌ์ worst case ๋ ์ด๋ค ๊ฒฝ์ฐ์ธ๊ฐ?
A. ํ์ชฝ์ผ๋ก ์น์ฐ์น ํธ๋ฆฌ๊ตฌ์กฐ๊ฐ ๋ ๋, ์ฆ ์ ํ์ฒ๋ผ ๋ณด์ผ ๋ worst case ๊ฐ ๋๋ค. (linked list ์ ๋ค๋ฅผ๊ฒ ์์ด์ง๊ธฐ ๋๋ฌธ)
๋ง์ฐฌ๊ฐ์ง๋ก BST ์ Worst case ๋ ํ์ชฝ์ผ๋ก ์น์ฐ์น ํธ๋ฆฌํํ ์ผ ๋๋ค.
Q. Hash Table ์ ์ด๋ค ์๋ฃ๊ตฌ์กฐ์ธ๊ฐ?
A. key-value ์์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ๋ฐ๋, ํจ์จ์ ์ธ ํ์์ ์ํ ์๋ฃ๊ตฌ์กฐ.
- hash function h() ๋ฅผ ์ด์ฉํด key - value ๋ฅผ Hash Table ์ ์ ์ฅํ๋ค.
- key ๋ ๋ฐ๋์ ์กด์ฌํด์ผํ๋ฉฐ, ์ค๋ณต๋ผ์ ์๋๋ค.
- Hash Table ์ ๊ตฌ์ฑํ๋ key - value ๋ฅผ ์ ์ฅํ ์ ์๋ ๊ณต๊ฐ์ bucket ํน์ slot ์ด๋ผ ๋ถ๋ฅธ๋ค.
- ์๊ฐ ๋ณต์ก๋
- ์ ์ฅ, ํ์, ์ญ์ : O(1)
- collision : O(n)
Q. ์ข์ Hash function ์ ํน์ง์ ?
A. ๊ฐ ์ํฉ๋ง๋ค ์ข์ hash function ์ ํน์ง์ ๋ค๋ฅด์ง๋ง, ๋๋ต์ ์ธ ๊ธฐ์ค์ 1) ์ฐ์ฐ์๋๊ฐ ๋นจ๋ผ์ผํ๊ณ , 2) ํด์ ์ถฉ๋์ ๊ฐ๋ฅํ ํผํด์ผ ํ๋ค.
Q. collision ์ด๋?
A. key ๊ฐ์ ๋ค๋ฅด์ง๋ง, key ์ ํด์๊ฐ์ด ๊ฐ์ ๋ ๋ฐ์ํ๋ ์ถฉ๋์ ์๋ฏธํ๋ค. -> ์ค๋ณต๋๋ key ๋ ์์ง๋ง, Hash ๊ฐ์ ์ค๋ณต๋ ์ ์๋ค๋ ๋ป
Q. Collision ํด๊ฒฐ ๋ฐฉ๋ฒ์?
A. Seperate Chaining ๊ณผ Open Addressing 2๊ฐ์ง ๋ฐฉ์์ผ๋ก ํด๊ฒฐํ ์ ์๋ค.
- Open Addressing : ์ถ๊ฐ์ ์ธ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฉํ์ง ์๊ธฐ์, Seperate Chaining ์ ๋นํด ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ด ์ข๋ค.
- Linear Probing : ์ ํ ์กฐ์ฌ๋ฒ : ์ถฉ๋์ด ๋ฐ์ํ ํด์๊ฐ์ผ๋ก๋ถํฐ ์ผ์ ํ ๊ฐ ๋งํผ ๊ฑด๋๋ฐ์ด ๋น์ด์๋ Slot ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ค ( + 1, +2, +3 ... )
- Quadratic Probing : ์ด์ฐจ ์กฐ์ฌ๋ฒ :์ ํ ์กฐ์ฌ๋ฒ์ด 1๋จ์๋ก ๊ฑด๋๋ฐ์๋ค๋ฉด, ์ด์ฐจ ์กฐ์ฌ๋ฒ์ ์ ๊ณฑ์๋ก ๊ฑด๋๋ฐ์ด ๋น slot ์ ํ์ํ๋ค (+1, +4, +9 ... )
- Double Hashing : Linear / Quadratic Probing ์ ํ์ฌ ์ด๋ํญ์ด ์ผ์ ํ๊ธฐ ๋๋ฌธ์, ํน์ ์์ญ์ ๋ฐ์ดํฐ๊ฐ ๋ชฐ๋ฆฌ๋ clustering ํ์์ด ๋ฐ์ํ ์ ์๋ค.(clustering -> ํ์์๊ฐ์ด ๊ธธ์ด์ง๋ ๋ฌธ์ ๋ฐ์) Clustering ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด 2๊ฐ์ ํด์ํจ์๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ์์ Double Hashing ์ด๋ผ ํ๋ค. ํ๋๋ ์ต์ด์ Hash ๊ฐ์ ์ป์ ๋ ์ฌ์ฉํ๊ณ , ๋๋ฒ ์งธ๋ collision ๋ฐ์ ์ ํ์ฌ ์ด๋ํญ์ ์ป๊ธฐ ์ํด ์ฌ์ฉํ๋ค.
- Seperate Chaining : Linked List (or Tree) ๋ฅผ ์ด์ฉํ์ฌ Collision ์ ํด๊ฒฐํ๋ค.
- ์ถฉ๋์ด ๋ฐ์์ Linked List ์ ๋ ธ๋๋ฅผ ์ถ๊ฐํ์ฌ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ค. ์ฆ ๊ฐ์ ์ฌ๋กฏ์ ๋งํฌ๋ ๋ฆฌ์คํธ๋ฅผ ๊ณ์ ์ถ๊ฐํ์ฌ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๊ฒ์ด๋ค.
- ์ฝ์ ์ : ์๋ก ๋ค๋ฅธ ๋ key ๊ฐ ๊ฐ์ ํด์๊ฐ์ ๊ฐ์ง๋ฉด, linked list ์ ๋ ธ๋๋ฅผ ์ถ๊ฐํ์ฌ key - value ๋ฅผ ์ ์ฅ, ์๊ฐ ๋ณต์ก๋๋ O(1)
- ์ญ์ ์ : ๊ธฐ๋ณธ์ ์ผ๋ก O(1), worst case ๋ O(N)
- ์กฐํ ์ : ๊ธฐ๋ณธ์ ์ผ๋ก O(1), worst case ๋ O(N). -> Worst case : ์๋ก ๋ค๋ฅธ n ๊ฐ์ key ๊ฐ ๋์ผํ ํด์๊ฐ์ ๊ฐ๊ฒ ๋๋ฉด, ๊ธธ์ด n ์ linked list ๋ฅผ ์์ฑํ๋ค. => ์๊ฐ๋ณต์ก๋ O(N) ์ผ๋ก ์ฆ๊ฐ.
'๐คฟ ์จ์ฐธ๊ณ Deep Dive' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฅ ๋ค์ด๋ถ] ์ด์งํธ๋ฆฌ, ์ด์งํ์ํธ๋ฆฌ, B-Tree, B+Tree ๊ฐ๋ ๊ณผ ๊ผฌ๋ฆฌ์ง๋ฌธ (0) | 2023.03.08 |
---|---|
ํ์ด์ง์ด๋? (0) | 2022.11.04 |