1๏ธโฃ ์๋ฃ๊ตฌ์กฐ(Data Structure)
์๋ฃ๊ตฌ์กฐ(Data Structure)๋ ๋ฐ์ดํฐ๋ฅผ ํจ์จ์ ์ผ๋ก ์ ์ฅํ๊ณ ๊ด๋ฆฌํ๋ฉฐ, ์ด๋ฅผ ํตํด ๋ฐ์ดํฐ๋ฅผ ํจ์จ์ ์ผ๋ก ์ ๊ทผํ๊ณ ์์ ํ ์ ์๋๋ก ํ๋ ์ฒด๊ณ์ ์ธ ๋ฐฉ๋ฒ์ ๋๋ค.
์๋ฃ๊ตฌ์กฐ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ฑ๋ฅ์ ์ต์ ํํ๊ณ ํ๋ก๊ทธ๋จ์ ํจ์จ์ฑ์ ํฅ์์ํค๋ ๋ฐ ์ค์ํ ์ญํ ์ ํฉ๋๋ค.
๊ธฐ๋ณธ ๊ฐ๋ .
์๋ฃ๊ตฌ์กฐ๋ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๋ฐฉ์๊ณผ ๋ฐ์ดํฐ๋ฅผ ์กฐ์ํ๋ ๋ฐฉ๋ฒ์ ์ ์ํฉ๋๋ค.
์ด๋ ๋ฐ์ดํฐ๋ฅผ ์ด๋ป๊ฒ ๋ฐฐ์ดํ๊ณ , ์ ๊ทผํ๊ณ , ์์ ํ๊ณ , ์ญ์ ํ ์ง๋ฅผ ๊ท์ ํ๋ ๊ท์น๊ณผ ๋ฐฉ๋ฒ์ ์งํฉ์ ๋๋ค.
์ฃผ์ ๋ชฉ์ .
-
ํจ์จ์ ์ธ ๋ฐ์ดํฐ ์ ์ฅ ๋ฐ ์ ๊ทผ.
- ๋ฐ์ดํฐ๋ฅผ ํจ์จ์ ์ผ๋ก ์ ์ฅํ์ฌ ๋น ๋ฅด๊ฒ ์ ๊ทผํ๊ณ ๊ฒ์ํ ์ ์๋๋ก ํฉ๋๋ค.
-
๋ฐ์ดํฐ ์์ ๋ฐ ์ญ์ ์ฉ์ด.
- ๋ฐ์ดํฐ๋ฅผ ์ฝ๊ฒ ์์ ํ๊ณ ์ญ์ ํ ์ ์๋๋ก ํฉ๋๋ค.
-
์๊ณ ๋ฆฌ์ฆ ์ต์ ํ.
- ์๊ณ ๋ฆฌ์ฆ์ ์ฑ๋ฅ์ ์ต์ ํํ๊ณ ์คํ ์๊ฐ์ ๋จ์ถ์ํต๋๋ค.
์ฃผ์ ์ข ๋ฅ.
-
๋ฐฐ์ด(Array)
- ๊ณ ์ ๋ ํฌ๊ธฐ์ ์ฐ์๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํฉ๋๋ค.
- ์ธ๋ฑ์ค๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ์ ๋น ๋ฅด๊ฒ ์ ๊ทผํ ์ ์์ต๋๋ค.
-
์ฐ๊ฒฐ ๋ฆฌ์คํธ(Linked List)
- ๊ฐ ์์๊ฐ ๋ฐ์ดํฐ์ ๋ค์ ์์๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ๋ฅผ ํฌํจํฉ๋๋ค.
- ๋์ ํฌ๊ธฐ ์กฐ์ ์ด ๊ฐ๋ฅํ๋ฉฐ ์ฝ์ ๊ณผ ์ญ์ ๊ฐ ์ฉ์ดํฉ๋๋ค.
-
์คํ(Stack)
- ํ์ ์ ์ถ(LIFO, Last In First Out) ๋ฐฉ์์ผ๋ก ๋์ํฉ๋๋ค.
- ๋ฐ์ดํฐ๋ฅผ ์ฝ์ ํ๋ push์ ์ญ์ ํ๋ pop ์ฐ์ฐ์ ๊ฐ์ง๋๋ค.
-
ํ(Queue)
- ์ ์ ์ ์ถ(FIFO, First In First Out) ๋ฐฉ์์ผ๋ก ๋์ํฉ๋๋ค.
- ๋ฐ์ดํฐ๋ฅผ ์ฝ์ ํ๋ enqueue์ ์ญ์ ํ๋ dequeue ์ฐ์ฐ์ ๊ฐ์ง๋๋ค.
-
ํธ๋ฆฌ(Tree)
- ๊ณ์ธต์ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๋ฉฐ, ๋ ธ๋์ ์์ง๋ก ๊ตฌ์ฑ๋ฉ๋๋ค.
- ์ด์ง ํธ๋ฆฌ, ์ด์ง ํ์ ํธ๋ฆฌ, AVL ํธ๋ฆฌ ๋ฑ ๋ค์ํ ํํ๊ฐ ์์ต๋๋ค.
-
๊ทธ๋ํ(Graph)
- ๋ ธ๋(์ ์ )์ ์์ง(๊ฐ์ )๋ก ๊ตฌ์ฑ๋ ์๋ฃ๊ตฌ์กฐ๋ก, ๋ค์ํ ๊ด๊ณ๋ฅผ ํํํ ์ ์์ต๋๋ค.
- ๋ฐฉํฅ ๊ทธ๋ํ, ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ ๋ฑ์ด ์์ต๋๋ค.
-
ํด์ ํ
์ด๋ธ(Hash Table)
- ํค-๊ฐ ์์ ์ ์ฅํ๋ฉฐ, ํด์ ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ์ ๋น ๋ฅด๊ฒ ์ ๊ทผํ ์ ์์ต๋๋ค.
- ์ถฉ๋ ํด๊ฒฐ ๋ฐฉ๋ฒ์ผ๋ก ์ฒด์ด๋๊ณผ ๊ฐ๋ฐฉ ์ฃผ์๋ฒ์ด ์์ต๋๋ค.
์์ฉ ์ฌ๋ก.
์๋ฃ๊ตฌ์กฐ๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค, ์ด์์ฒด์ , ๋คํธ์ํฌ, ์ธ๊ณต์ง๋ฅ, ๊ฒ์ ๊ฐ๋ฐ ๋ฑ ๋ค์ํ ๋ถ์ผ์์ ์ค์ํ ์ญํ ์ ํฉ๋๋ค.
์ ์ ํ ์๋ฃ๊ตฌ์กฐ์ ์ ํ์ ํ๋ก๊ทธ๋จ์ ์ฑ๋ฅ๊ณผ ํจ์จ์ฑ์ ํฌ๊ฒ ํฅ์์ํฌ ์ ์์ต๋๋ค.
2๏ธโฃ ์๋ฃ๊ตฌ์กฐ์ ๋ถ๋ฅ
1๏ธโฃ ์ ํ ์๋ฃ๊ตฌ์กฐ(Linear Data Structure)
์ ํ ์๋ฃ๊ตฌ์กฐ(Linear Data Structure)๋ ๋ฐ์ดํฐ ์์๋ค์ด ์์ฐจ์ ์ผ๋ก ๋ฐฐ์ด๋ ๊ตฌ์กฐ๋ฅผ ์๋ฏธํฉ๋๋ค.
์ด ์๋ฃ๊ตฌ์กฐ์์๋ ๋ฐ์ดํฐ ์์๋ค์ด ์ง์ ํํ๋ก ์ฐ๊ฒฐ๋์ด ์์ผ๋ฉฐ, ๊ฐ ์์๋ ํ ๋ค์ ์์๋ ์ด์ ์์์ ์ฐ๊ฒฐ๋์ด ์์ต๋๋ค.
์ ํ ์๋ฃ๊ตฌ์กฐ์ ์ฃผ์ ํน์ง์ธ ๋ฐ์ดํฐ ์์๋ค์ด ํ ์ค๋ก ๋ฐฐ์ด๋์ด ์๋ค๋ ์ ์ ๋๋ค.
์ฃผ์ ์ ํ ์๋ฃ๊ตฌ์กฐ๋ฅด๋ ๋ฐฐ์ด, ์ฐ๊ฒฐ ๋ฆฌ์คํธ, ์คํ, ํ ๋ฑ์ด ์์ต๋๋ค.
์ฃผ์ ์ ํ ์๋ฃ๊ตฌ์กฐ.
-
๋ฐฐ์ด(Array)
- ์ ์ : ๋์ผํ ํ์ ์ ๋ฐ์ดํฐ ์์๋ค์ด ์ฐ์๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ ์ฅ๋๋ ์๋ฃ๊ตฌ์กฐ์ ๋๋ค.
- ํน์ง : ๊ณ ์ ๋ ํฌ๊ธฐ๋ฅผ ๊ฐ์ง๋ฉฐ ์ธ๋ฑ์ค๋ฅผ ํตํด ๋ฐ์ดํฐ์ ๋น ๋ฅด๊ฒ ์ ๊ทผํ ์ ์์ต๋๋ค.
- ์์ : ์ ์ํ ๋ฐฐ์ด, ๋ฌธ์์ด ๋ฐฐ์ด ๋ฑ.
-
์ฐ๊ฒฐ ๋ฆฌ์คํธ(Linked List)
- ์ ์ : ๊ฐ ๋ฐ์ดํฐ ์์๊ฐ ๋ ธ๋๋ก ๊ตฌ์ฑ๋๊ณ , ๊ฐ ๋ ธ๋๋ ๋ฐ์ดํฐ์ ๋ค์ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ๋ฅผ ํฌํจํ๋ ์๋ฃ๊ตฌ์กฐ์ ๋๋ค.
- ํน์ง : ๋์ ํฌ๊ธฐ ์กฐ์ ์ด ๊ฐ๋ฅํ๋ฉฐ ์ฝ์ ๊ณผ ์ญ์ ๊ฐ ์ฉ์ดํ์ง๋ง, ์ธ๋ฑ์ค๋ฅผ ํตํ ์ ๊ทผ์ ๋ฐฐ์ด๋ณด๋ค ๋๋ฆฝ๋๋ค.
- ์ข ๋ฅ : ๋จ์ผ ์ฐ๊ฒฐ ๋ฆฌ์คํธ, ์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ, ์ํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ ๋ฑ.
-
์คํ(Stack)
- ์ ์ : ํ์ ์ ์ถ(LIFO, Last In First Out) ๋ฐฉ์์ผ๋ก ๋์ํ๋ ์๋ฃ๊ตฌ์กฐ์ ๋๋ค.
- ํน์ง : ๋ฐ์ดํฐ ์ฝ์ (push)๊ณผ ์ญ์ (pop)์ด ํ์ชฝ ๋์์๋ง ์ด๋ฃจ์ด์ง๋๋ค.
- ์ฌ์ฉ ์ฌ๋ก : ํจ์ ํธ์ถ ์คํ, ์ญ์ ๋ฌธ์์ด ์ฒ๋ฆฌ ๋ฑ.
-
ํ(Queue)
- ์ ์ : ์ ์ ์ ์ถ(FIFO, First In First Out) ๋ฐฉ์์ผ๋ก ๋์ํ๋ ์๋ฃ๊ตฌ์กฐ์ ๋๋ค.
- ํน์ง : ๋ฐ์ดํฐ์ ์ฝ์ (enqueue)์ ํ์ชฝ ๋(ํ๋จ)์์, ์ญ์ (dequeue)๋ ๋ฐ๋์ชฝ ๋(์ ๋จ)์์ ์ด๋ฃจ์ด์ง๋๋ค.
- ์ข ๋ฅ : ์ํ ํ, ์ฐ์ ์์ ํ, ๋ฑ(Deque) ๋ฑ.
- ์ฌ์ฉ ์ฌ๋ก : ์ด์ ์ฒด์ ์ ์์ ์ค์ผ์ค๋ง, ํ๋ฆฐํฐ ๋๊ธฐ์ด ๋ฑ.
์ ํ ์๋ฃ๊ตฌ์กฐ์ ํน์ง ๋ฐ ์ฅ๋จ์ .
-
ํน์ง.
- ์์ฐจ์ ์ ๊ทผ์ด ๊ฐ๋ฅํ๋ฉฐ, ๋ฐ์ดํฐ๋ฅผ ์ฐจ๋ก๋๋ก ์ฒ๋ฆฌํ ๋ ์ ๋ฆฌํฉ๋๋ค.
- ๋ฉ๋ชจ๋ฆฌ์์ ์ฐ์์ ์ผ๋ก ๋ฐฐ์น๋๋ฏ๋ก ์ธ๋ฑ์ค๋ฅผ ํตํด ์ง์ ์ ๊ทผํ ์ ์์ต๋๋ค.(๋ฐฐ์ด์ ๊ฒฝ์ฐ)
-
์ฅ์ .
- ๊ฐ๋จํ๊ณ ๊ตฌํ์ด ์ฉ์ดํฉ๋๋ค.
- ๋ฐ์ดํฐ์ ์ฝ์ ๊ณผ ์ญ์ ๊ฐ ํน์ ์กฐ๊ฑด ํ์ ํจ์จ์ ์ผ ์ ์์ต๋๋ค(์: ์คํ, ํ)
-
๋จ์
- ๋ฐ์ดํฐ ํฌ๊ธฐ์ ๋ฐ๋ผ ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค(๋ฐฐ์ด์ ๊ฒฝ์ฐ).
- ํน์ ์์ ์ ๊ทผ์ด๋ ์ฝ์ /์ญ์ ์ ์ฑ๋ฅ์ด ์ ํ๋ ์ ์์ต๋๋ค(์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ๊ฒฝ์ฐ)
๋ง๋ฌด๋ฆฌ.
์ ํ ์๋ฃ๊ตฌ์กฐ๋ ๋ฐ์ดํฐ๊ฐ ์์ฐจ์ ์ผ๋ก ์ฐ๊ฒฐ๋์ด ์์ด ์์ฐจ์ ์ฒ๋ฆฌ์ ์ ํฉํ๋ฉฐ, ํ๋ก๊ทธ๋จ์ ๋ค์ํ ๋ถ๋ถ์์ ์ฌ์ฉ๋๋ ๊ธฐ์ด์ ์ธ ์๋ฃ๊ตฌ์กฐ์ ๋๋ค.
2๏ธโฃ ๋น์ ํ ์๋ฃ๊ตฌ์กฐ(Non-linear Data Structure)
๋น์ ํ ์๋ฃ๊ตฌ์กฐ(Non-linear Data Structure)๋ ๋ฐ์ดํฐ ์์๋ค์ด ๊ณ์ธต์ ๋๋ ๊ทธ๋ฌผ ํํ๋ก ๋ฐฐ์ด๋ ๊ตฌ์กฐ๋ฅผ ์๋ฏธํฉ๋๋ค.
์ด ์๋ฃ๊ตฌ์กฐ์์๋ ๋ฐ์ดํฐ ์์๋ค์ด ์์ฐจ์ ์ผ๋ก ๋ฐฐ์ด๋์ง ์๊ณ , ํ๋์ ์์๊ฐ ์ฌ๋ฌ ์์๋ค๊ณผ ์ฐ๊ฒฐ๋ ์ ์์ต๋๋ค.
์ฃผ์ ๋น์ ํ ์๋ฃ๊ตฌ์กฐ๋ก๋ ํธ๋ฆฌ(Tree)์ ๊ทธ๋ํ(Graph)๊ฐ ์์ต๋๋ค.
์ฃผ์ ๋น์ ํ ์๋ฃ๊ตฌ์กฐ.
-
ํธ๋ฆฌ(Tree)
- ์ ์ : ๋ ธ๋์ ๊ทธ ๋ ธ๋๋ค์ ์ฐ๊ฒฐํ๋ ๊ฐ์ ์ผ๋ก ๊ตฌ์ฑ๋ ๊ณ์ธต์ ์๋ฃ๊ตฌ์กฐ์ ๋๋ค. ํธ๋ฆฌ๋ ๋ฃจํธ ๋ ธ๋์์ ์์ํ์ฌ ์์ ๋ ธ๋๋ก ๋ถ๊ธฐํ๋ฉฐ, ์ฌ์ดํด์ด ์์ต๋๋ค.
- ํน์ง : ํธ๋ฆฌ๋ ๊ณ์ธต์ ๊ด๊ณ๋ฅผ ๋ํ๋ด๋ฉฐ, ๊ฐ ๋ ธ๋๋ 0๊ฐ ์ด์์ ์์ ๋ ธ๋๋ฅผ ๊ฐ์ง ์ ์์ต๋๋ค.
-
์ข
๋ฅ :
- ์ด์ง ํธ๋ฆฌ(Binary Tree) : ๊ฐ ๋ ธ๋๊ฐ ์ต๋ ๋ ๊ฐ์ ์์ ๋ ธ๋๋ฅผ ๊ฐ์ง๋ ํธ๋ฆฌ์ ๋๋ค.
- ์ด์ง ํ์ ํธ๋ฆฌ(Binary Search Tree) : ์ผ์ชฝ ์์์ ๋ถ๋ชจ๋ณด๋ค ์๊ณ , ์ค๋ฅธ์ชฝ ์์์ ๋ถ๋ชจ๋ณด๋ค ํฐ ๊ฐ์ ๊ฐ์ง๋ ์ด์ง ํธ๋ฆฌ์ ๋๋ค.
- ๊ท ํ ์ด์ง ํธ๋ฆฌ(Balanced Binary Tree) : AVL ํธ๋ฆฌ, ๋ ๋-๋ธ๋ ํธ๋ฆฌ ๋ฑ๊ณผ ๊ฐ์ด ๋์ด๊ฐ ๊ท ํ์ ์ด๋ฃจ๋๋ก ์ ์ง๋๋ ํธ๋ฆฌ์ ๋๋ค.
- ํ(Heap) : ์์ ์ด์ง ํธ๋ฆฌ์ ์ผ์ข ์ผ๋ก, ์ต๋ ํ๊ณผ ์ต์ ํ์ด ์์ต๋๋ค.
- ํธ๋ผ์ด(Trie) : ๋ฌธ์์ด์ ์ ์ฅํ๊ณ ๋น ๋ฅด๊ฒ ๊ฒ์ํ๊ธฐ ์ํด ์ฌ์ฉ๋๋ ํธ๋ฆฌ์ ๋๋ค.
-
๊ทธ๋ํ(Graph)
- ์ ์ : ์ ์ (Vertex)๋ค๊ณผ ์ด ์ ์ ๋ค์ ์ฐ๊ฒฐํ๋ ๊ฐ์ (Edge)๋ค๋ก ๊ตฌ์ฑ๋ ์๋ฃ๊ตฌ์กฐ์ ๋๋ค.
- ํน์ง : ๊ทธ๋ํ๋ ๋ฐฉํฅ ๊ทธ๋ํ(Directed Graph)์ ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ(Undirceted Graph)๋ก ๋๋ ์ ์์ผ๋ฉฐ, ์ฌ์ดํด์ด ์กด์ฌํ ์ ์์ต๋๋ค.
-
์ข
๋ฅ :
- ๋ฐฉํฅ ๊ทธ๋ํ(Directed Graph) : ๊ฐ์ ์ ๋ฐฉํฅ์ฑ์ด ์๋ ๊ทธ๋ํ์ ๋๋ค.
- ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ(Undirected Graph) : ๊ฐ์ ์ ๋ฐฉํฅ์ฑ์ด ์๋ ๊ทธ๋ํ์ ๋๋ค.
- ๊ฐ์ค์น ๊ทธ๋ํ(Weighted Graph) : ๊ฐ์ ์ ๊ฐ์ค์น๊ฐ ๋ถ์ฌ๋ ๊ทธ๋ํ์ ๋๋ค.
- ๋น๊ฐ์ค์น ๊ทธ๋ํ(Unweighted Graph) : ๊ฐ์ ์ ๊ฐ์ค์น๊ฐ ์๋ ๊ทธ๋ํ์ ๋๋ค.
๋น์ ํ ์๋ฃ๊ตฌ์กฐ์ ํน์ง ๋ฐ ์ฅ๋จ์ .
-
ํน์ง :
- ๊ณ์ธต์ ๋๋ ๋คํธ์ํฌ ๊ตฌ์กฐ๋ฅผ ๋ํ๋ด๋ ๋ฐ ์ ํฉํฉ๋๋ค.
- ๋ณต์กํ ๊ด๊ณ๋ฅผ ํํํ ์ ์์ผ๋ฉฐ, ๋ฐ์ดํฐ ์์ ๊ฐ์ ๋ค๋๋ค ๊ด๊ณ๋ฅผ ์ฒ๋ฆฌํ ์ ์์ต๋๋ค.
-
์ฅ์ :
- ๋ฐ์ดํฐ์ ๊ณ์ธต์ ๊ตฌ์กฐ๋ฅผ ์ฝ๊ฒ ํํํ ์ ์์ต๋๋ค(ํธ๋ฆฌ).
- ๋ณต์กํ ์ฐ๊ฒฐ ๊ด๊ณ๋ฅผ ํจ๊ณผ์ ์ผ๋ก ๋ชจ๋ธ๋งํ ์ ์์ต๋๋ค(๊ทธ๋ํ).
- ํน์ ์ ํ์ ํ์, ์ ๋ ฌ, ๋ฐ์ดํฐ ์์ถ, ๋คํธ์ํฌ ๋ผ์ฐํ ๋ฑ์ ์ ์ฉํฉ๋๋ค.
-
๋จ์ :
- ๊ตฌํ๊ณผ ๊ด๋ฆฌ๊ฐ ์ ํ ์๋ฃ๊ตฌ์กฐ๋ณด๋ค ๋ณต์กํ ์ ์์ต๋๋ค.
- ํน์ ์์ (์: ํธ๋ฆฌ์ ๊ท ํ ์ ์ง, ๊ทธ๋ํ ํ์ ๋ฑ)์์ ์ถ๊ฐ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ด ํ์ํฉ๋๋ค.
๋ง๋ฌด๋ฆฌ.
๋น์ ํ ์๋ฃ๊ตฌ์กฐ๋ ๋ฐ์ดํฐ๊ฐ ๋จ์ํ ์์ฐจ์ ์ผ๋ก ๋ฐฐ์ด๋์ง ์๊ณ , ๋ณต์กํ ๊ด๊ณ๋ฅผ ๋ํ๋ด๋ ๊ฒฝ์ฐ์ ์ฌ์ฉ๋ฉ๋๋ค.
์๋ฅผ ๋ค์ด, ํ์ผ ์์คํ ์ ๋๋ ํฐ๋ฆฌ ๊ตฌ์กฐ, ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ธ๋ฑ์ค, ์์ ๋คํธ์ํฌ์ ์ฌ์ฉ์ ๊ด๊ณ ๋ฑ์ด ๋น์ ํ ์๋ฃ๊ตฌ์กฐ๋ฅผ ํ์ฉํ๋ ์ฌ๋ก์ ๋๋ค.
2๏ธโฃ ์๋ฃ๊ตฌ์กฐ์ ๊ตฌํ.
1๏ธโฃ ์ถ์ ์๋ฃํ(Abstract Data Type, ADT)
์๋ฐ ํ๋ก๊ทธ๋๋ฐ์์์ ์ถ์ ์๋ฃํ(Abstract Data Type, ADT)์ ๋ฐ์ดํฐ์ ๋ ผ๋ฆฌ์ ๊ตฌ์กฐ์ ์ด๋ฅผ ์กฐ์ํ๋ ์ฐ์ฐ๋ค์ ๋ช ํํ๊ฒ ์ ์ํ ๊ฐ๋ ์ ๋๋ค.
ADT๋ ๊ตฌํ ์ธ๋ถ ์ฌํญ์ ์จ๊ธฐ๊ณ , ๋ฐ์ดํฐ์ ์ฐ์ฐ์ ์ธํฐํ์ด์ค๋ฅผ ํตํด ์ฌ์ฉ์์๊ฒ ์ถ์์ ์ธ ์์ค์์ ๋ฐ์ดํฐ ์กฐ์์ ์ ๊ณตํฉ๋๋ค.
์ฆ, ADT๋ ๋ฐ์ดํฐ๊ฐ ์ด๋ป๊ฒ ์ ์ฅ๋๊ณ ๊ตฌํ๋๋์ง์ ๋ํ ์ ๋ณด๋ ๊ฐ์ถ๊ณ , ๋ฐ์ดํฐ์ ์ํธ์์ฉํ๋ ๋ฐฉ๋ฒ๋ง์ ์ ์ํฉ๋๋ค.
์ฃผ์ ๊ฐ๋
-
์ถ์ํ(Abstraction)
- ADT๋ ๋ฐ์ดํฐ๋ฅผ ์ถ์ํํ์ฌ ๋ฐ์ดํฐ์ ์ค์ ๊ตฌํ๊ณผ ๋ ๋ฆฝ์ ์ผ๋ก ์ฌ์ฉ๋ ์ ์๋๋ก ํฉ๋๋ค.
- ์ฌ์ฉ์๋ ๋ฐ์ดํฐ์ ์ ์ฅ ๋ฐฉ์์ด๋ ์ฐ์ฐ์ ๊ตฌํ ๋ฐฉ๋ฒ์ ์ ํ์ ์์ด, ADT๊ฐ ์ ๊ณตํ๋ ์ธํฐํ์ด์ค๋ฅผ ํตํด ๋ฐ์ดํฐ๋ฅผ ์กฐ์ํ ์ ์์ต๋๋ค.
-
์ธํฐํ์ด์ค(Interface)
- ADT๋ ๋ฐ์ดํฐ ํ์ ๊ณผ ์ด๋ฅผ ๋ค๋ฃจ๋ ์ฐ์ฐ๋ค์ ์ธํฐํ์ด์ค๋ฅผ ํตํด ์ ์ํฉ๋๋ค.
- ์๋ฐ์์๋ ์ธํฐํ์ด์ค(Interface) ํค์๋๋ฅผ ์ฌ์ฉํ์ฌ ADT์ ์ฐ์ฐ์ ์ ์ํ ์ ์์ต๋๋ค.
-
์บก์ํ(Encapsulation)
- ADT๋ ๋ฐ์ดํฐ์ ์ฐ์ฐ์ ํ๋์ ๋จ์๋ก ๋ฌถ์ด ์บก์ํํฉ๋๋ค.
- ๋ฐ์ดํฐ๋ฅผ ์ง์ ์ ๊ทผํ์ง ์๊ณ , ์ ์๋ ์ฐ์ฐ์ ํตํด์๋ง ์ ๊ทผํ ์ ์๋๋ก ํ์ฌ ๋ฐ์ดํฐ ๋ฌด๊ฒฐ์ฑ์ ๋ณด์ฅํฉ๋๋ค.
์๋ฐ์์์ ADT ์์
๋ค์์ ์๋ฐ์์ ์คํ(Stack) ADT๋ฅผ ์ ์ํ๊ณ ๊ตฌํํ๋ ์์์ ๋๋ค.
์คํ ์ธํฐํ์ด์ค ์ ์
public interface Stack<T> {
void push(T item); // ์คํ์ ์์ดํ
์ ์ถ๊ฐ
T pop(); // ์คํ์์ ์์ดํ
์ ์ ๊ฑฐํ๊ณ ๋ฐํ
T peek(); // ์คํ์ ๋งจ ์ ์์ดํ
์ ๋ฐํ(์ ๊ฑฐํ์ง ์์)
boolean isEmpty(); // ์คํ์ด ๋น์ด ์๋์ง ํ์ธ
int size(); // ์คํ์ ํฌ๊ธฐ ๋ฐํ
}
์คํ ๊ตฌํ
import java.util.ArrayList;
import java.util.List;
public class ArrayListStack<T> implements Stack<T> {
private List<T> list = new ArrayList<>();
@Override
public void push(T item) {
list.add(item);
}
@Override
public T pop() {
if (isEmpty()) {
throw new RuntimException("Stack is empty");
}
return list.remove(list.size() - 1);
}
@Override
public T peek() {
if (isEmpty()) {
throw new RuntimeException("Stack is empty");
}
return list.get(list.size() - 1);
}
@Override
public boolean isEmpty() {
return list.isEmpty();
}
@Override
public int size() {
return list.size();
}
}
์ค๋ช
-
โ
Stack<T>
โ ์ธํฐํ์ด์ค๋ ์คํ ADT์ ์ฐ์ฐ์ ์ ์ํฉ๋๋ค. ์ด ์ธํฐํ์ด์ค๋ โpushโ, โpopโ, โpeekโ, โisEmptyโ, โsizeโ ๋ฉ์๋๋ฅผ ํฌํจํฉ๋๋ค. -
โ
ArrayListStack<T>
โ ํด๋์ค๋ โStack<T>
โ ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํฉ๋๋ค. ์ด ํด๋์ค๋ โArrayListโ ๋ฅผ ๋ด๋ถ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ก ์ฌ์ฉํ์ฌ ์คํ ์ฐ์ฐ์ ๊ตฌํํฉ๋๋ค. - โpushโ ๋ฉ์๋๋ ์คํ์ ์์ดํ ์ ์ถ๊ฐํฉ๋๋ค.
- โpopโ ๋ฉ์๋๋ ์คํ์์ ๋งจ ์์ ์์ดํ ์ ์ ๊ฑฐํ๊ณ ๋ฐํํฉ๋๋ค.
- โpeekโ ๋ฉ์๋๋ ์คํ์ ๋งจ ์ ์์ดํ ์ ์ ๊ฑฐํ์ง ์๊ณ ๋ฐํํฉ๋๋ค.
- โisEmptyโ ๋ฉ์๋๋ ์คํ์ด ๋น์ด ์๋์ง ํ์ธํฉ๋๋ค.
- โsizeโ ๋ฉ์๋๋ ์คํ์ ํฌ๊ธฐ๋ฅผ ๋ฐํํฉ๋๋ค.
์ด ์์์์ โStack<T>
โ ์ธํฐํ์ด์ค๋ ์คํ ADT๋ฅผ ์ ์ํ๊ณ , โArrayListStack<T>
โ ํด๋์ค๋ ์ด ADT๋ฅผ ๊ตฌํํ ๊ฒ์
๋๋ค.
์ฌ์ฉ์๋ โArrayListStackโ ์ ๋ด๋ถ ๊ตฌํ์ ์ ํ์ ์์ด โStackโ ์ธํฐํ์ด์ค๋ฅผ ํตํด ์คํ ์ฐ์ฐ์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
์ด๋ ADT์ ์ฃผ์ ์ฅ์ ์ค ํ๋์ธ ๊ตฌํ์ ๋ ๋ฆฝ์ฑ์ ์ ๋ณด์ฌ์ค๋๋ค.