์๋ฃ๊ตฌ์กฐ?
- Data structures are specialized formats for organizing and storing data in a computer so that it can be used efficiently.
์ ์ค์ํ๊ฐ
- Data structures are crucial in the field of computer science and coding because they offer a method of organizing and storing data in an efficient and manageable format. Theyโre critical because they form the foundation for modern algorithm design. Your ability to choose or design the most suited data structure for a particular task can be the difference between a solution thatโs functional and efficient and one that isnโt.
๋ณต์ก๋
- ์๊ฐ ๋ณต์ก๋
- ์๊ณ ๋ฆฌ์ฆ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ์ ๋ ฅ ํฌ๊ธฐ n์ ๋ํ ํจ์๋ก ๋ํ๋ธ ๊ฒ
- ๊ณต๊ฐ ๋ณต์ก๋
- ์๊ณ ๋ฆฌ์ฆ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐ ํ์ํ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ ๋ ฅ ํฌ๊ธฐ n์ ๋ํ ํจ์๋ก ๋ํ๋ธ ๊ฒ
- ๋น
์ค ํ๊ธฐ๋ฒ
- (์ต์ ์ ๊ฒฝ์ฐ๋ฅผ ์ฐ์ )

- ์ข์ ์๊ณ ๋ฆฌ์ฆ์?
- ์๊ฐ-๊ณต๊ฐ ๋ณต์ก๋๊ฐ ๋ฎ๊ณ , ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ์๊ณ ๋ฆฌ์ฆ
๊ธฐ์ด ์๋ฃ ๊ตฌ์กฐ
- Sequence Container
- Array
- Linked Lists
- Stacks
- Queues
- Hash Tables
- ๊ด๋ จ ์๊ณ ๋ฆฌ์ฆ
- ํ์
- ์์ ํ์
- ์ด์ง ํ์
- ์ ๋ ฌ
- bubble
- insertion
- selection
- merge
- quick
- heap
- ํ์
Array (๋ฐฐ์ด)
- ์ ์
- ๊ฐ์ ์๋ฃํ์ ์์๋ค์ ์ผ์ ํ ํฌ๊ธฐ์ ์ฐ์๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์์๋๋ก ์ ์ฅํ๊ณ , ์ธ๋ฑ์ค๋ฅผ ํตํด ๊ฐ ์์์ ๋น ๋ฅด๊ฒ ์ ๊ทผํ ์ ์๋ ์๋ฃ๊ตฌ์กฐ
- ์ธ์ด๋ณ
- cpp -
vector, array, [] - c
[], alloc 
- python -
list, []- ํ์ด์ฌ์์ ๋ฆฌ์คํธ๋ผ๊ณ ๋ถ๋ฆ

- cpp -
- ์๊ฐ ๋ณต์ก๋
- ์ฝ์
- ๋์์๋ง ์ฝ์ ํ๋ฉด
- ์ญ์
- ๋์์๋ง ์ฝ์ ํ๋ฉด
- ์ ๊ทผ
- ์ฝ์
- ๊ณต๊ฐ ๋ณต์ก๋
- ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ธ์ ๋์ด ์์ด ํจ์จ์ด ์ข์
- ๋ฐฐ์ด ์ข
๋ฅ

- ํฌ๊ธฐ ๊ธฐ๋ฐ
- ๊ณ ์
- ๋์
- ์ฐจ์ ๊ธฐ๋ฐ
- 1์ฐจ์
- 2์ฐจ์
- 3์ฐจ์
- 1์ฐจ์
Linked Lists (์ฐ๊ฒฐ ๋ฆฌ์คํธ)
- ์ ์
- ๋ฐ์ดํฐ๋ฅผ ๋ด์ ๋ ธ๋๋ค์ด ํฌ์ธํฐ(์ฐธ์กฐ)๋ฅผ ์ด์ฉํด ์๋ก ์ฐ๊ฒฐ๋์ด ์๋ ์ ํ ์๋ฃ๊ตฌ์กฐ๋ก, ๋ฉ๋ชจ๋ฆฌ ์์์ ์ฐ์์ ์ผ๋ก ๋ฐฐ์น๋์ง ์๊ณ ํ์ํ ๋๋ง๋ค ๋์ ์ผ๋ก ์์ฑ๋์ด ์ฝ์ ๊ณผ ์ญ์ ๊ฐ ์ฉ์ดํ ๊ตฌ์กฐ

- ์ธ์ด๋ณ
- cpp -
list
- cpp -
- ์๊ฐ ๋ณต์ก๋
- ์ฝ์
- ์ญ์
- ์ ๊ทผ
- ์ฝ์
- ๊ณต๊ฐ ๋ณต์ก๋
- ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ฐ์์ ์ผ๋ก ํ ๋น๋์ง์์, ๋ฐฐ์ด๋ณด๋ค ๋ฏธ์ธํ๊ฒ ๋๋ฆฌ๋ค(์ ์์ค์์)
Stack (์คํ)
- ์ ์
- ํ์ ์ ์ถ(LIFO, Last-In First-Out) ๋ฐฉ์์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ณ ๊บผ๋ด๋ ์ ํ ์๋ฃ๊ตฌ์กฐ
- ๋ฐ์ดํฐ์ ์ฝ์ ์ push, ์ญ์ ๋ pop ์ฐ์ฐ์ ํตํด ์ด๋ฃจ์ด์ง๋ฉฐ, ๊ฐ์ฅ ๋ง์ง๋ง์ ์ฝ์ ๋ ์์๊ฐ ๊ฐ์ฅ ๋จผ์ ์ ๊ฑฐ

- ์ธ์ด๋ณ
- cpp -
stack - python -
list, []
- cpp -
- ์๊ฐ ๋ณต์ก๋
- ์ฝ์
- ์ญ์
- ์ ๊ทผ
- ๋งจ์์ ์์๋ง ์ ๊ทผ ๊ฐ๋ฅ
- ์ค๊ฐ ์์์ ์ ๊ทผํ๋ ค๋ฉด ๊บผ๋ด์ผํ๋ค
- ๋งจ์์ ์์๋ง ์ ๊ทผ ๊ฐ๋ฅ
- ์ฝ์
- ๊ณต๊ฐ ๋ณต์ก๋
Queue (ํ)
- ์ ์
- ์ ์ ์ ์ถ(FIFO, First-In First-Out) ๋ฐฉ์์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ณ ๊บผ๋ด๋ ์ ํ ์๋ฃ๊ตฌ์กฐ
- ๋ฐ์ดํฐ์ ์ฝ์ ์ rear(๋ค)์์, ์ญ์ ๋ front(์)์์ ์ด๋ฃจ์ด์ง๋ค

- ์๋ค๋ก ๋๋ค ์ฝ์
, ์ญ์ ํ ์ ์๋
Dequeue๋ ์๋ค
- ์ธ์ด๋ณ
- cpp -
queue - python -
dequefrom collections import deque
- cpp -
- ์๊ฐ ๋ณต์ก๋
- ์ฝ์
/ ์ญ์ / ์ ๊ทผ
- ๋ค์์๋ง ๊ฐ๋ฅ
- deque๋ ์๋ค๋ก ๋๋ค ๊ฐ๋ฅ
- ๋ค์์๋ง ๊ฐ๋ฅ
- ์ฝ์
/ ์ญ์ / ์ ๊ทผ
- ๊ณต๊ฐ ๋ณต์ก๋
- ๊ตฌํ์ ๋ฐ๋ผ ๋ค๋ฆ
- ๋ฐฐ์ด ๊ธฐ๋ฐ ๊ตฌํ
- ์ฐ๊ฒฐ ๋ฆฌ์คํธ ๊ธฐ๋ฐ ๊ตฌํ
- โฆ
- ๊ตฌํ์ ๋ฐ๋ผ ๋ค๋ฆ
Hash Table (ํด์ฌ ๋งต)
- ์ ์
- {key, value}
- ํด์๋งต(Hash Map)์ ํค(key)์ ๊ฐ(value)์ ์์ผ๋ก ์ ์ฅ
- ํด์ ํจ์(hash function)๋ฅผ ์ด์ฉํด ํค๋ฅผ ํด์๊ฐ์ผ๋ก ๋ณํํ์ฌ ๋ฐฐ์ด ์ธ๋ฑ์ค์ ๋งคํํด ๋น ๋ฅด๊ฒ ๊ฒ์ยท์ฝ์ ยท์ญ์ ํ ์ ์๋ ์๋ฃ๊ตฌ์กฐ

- ํด์ฑ
- ํด์ฌ ํจ์๋ฅผ ์คํํจ์ ๋ปํจ
- ํด์ฑ์ ๊ฒฐ๊ณผ ๊ฐ์ ํค๋ก ๋ฐฐ์ ๋ ์ ์๋๋ฐ, ์ด๋ฅผ
ํค ์ถฉ๋์ด๋ผ ๋ถ๋ฅธ๋ค- ํค ์ถฉ๋ ํด๊ฒฐ ๋ฐฉ๋ฒ๋ก
- ์ฒด์ด๋
- ๊ฐ์ ํค์๋ค๊ฐ ๋ฆฌ์คํธ(๋ฐฐ์ด)๋ก ์ ์ฅ
- ๊ฐ๋ฐฉ ์ฃผ์๋ฒ
- ๋ค๋ฅธ ๋น ์ฌ๋กฏ์ ์ฐพ์์ ์ ์ฅ
- โฆ
- ์ฒด์ด๋
- ํค ์ถฉ๋ ํด๊ฒฐ ๋ฐฉ๋ฒ๋ก
- ์ธ์ด๋ณ
- cpp -
unordered_map, unordered_set - python -
dict, {}
- cpp -
- ์๊ฐ ๋ณต์ก๋
- ์ฝ์
/ ์ญ์ / ์ ๊ทผ
- ์ถฉ๋์ด ๋ง์ ๋์ ์ฝ์
/ ์ญ์ / ์ ๊ทผ
- ์ฝ์
/ ์ญ์ / ์ ๊ทผ
๊ทธ๋ํ
-
๊ทธ๋ํ
- ๋ ธ๋(์ ์ , Vertex)์ ๋ ธ๋๋ค์ ์ฐ๊ฒฐํ๋ ๊ฐ์ (Edge)์ผ๋ก ๊ตฌ์ฑ๋ ์๋ฃ๊ตฌ์กฐ

- ์ข
๋ฅ
- ๋ฐฉํฅ์ฑ

- ๋ฐฉํฅ ๊ทธ๋ํ
- ๋จ๋ฐฉํฅ
- ์๋ฐฉํฅ
- ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ
- ์ฐ๊ฒฐ์ฑ

- ์ฐ๊ฒฐ ๊ทธ๋ํ
- ๋น์ฐ๊ฒฐ ๊ทธ๋ํ
- ๊ฐ์ค์น

- ๊ฐ์ค ๊ทธ๋ํ
- ๋น๊ฐ์ค ๊ทธ๋ํ
- ํน์ ํํ
- ์ฌ์ดํด ๊ทธ๋ํ
- ํธ๋ฆฌ
- โฆ
- ๋ฐฉํฅ์ฑ
- ๊ทธ๋ํ ํํ๋ฒ
- ์ธ์ ํ๋ ฌ
- ์ธ์ ๋ฆฌ์คํธ
- ์ธ์ ํ๋ ฌ
- ๊ทธ๋ํ์์์ ๊ฒ์
- BFS (๋๋น ์ฐ์ ํ์, Breadth First Search)
- DFS (๊น์ด ์ฐ์ ํ์, Depth First Search)

-
ํธ๋ฆฌ

- ๊ทธ๋ํ์ ํ ์ข
๋ฅ, ์ฌ์ดํด์ด ์๋ ๊ฒฝ์ฐ๋ฅผ ๋ปํจ
- ์ด์ง ํธ๋ฆฌ
- ํ
- ์ต์, ์ต๋ ๊ฐ์ ๋น ๋ฅด๊ฒ ์ป๊ธฐ ์ํ ์๋ฃ ๊ตฌ์กฐ
- ๋ก ๊ฐ์ ๊ตฌํจ
- ์ฝ์ ์ ์ผ๋ก ์ ๋ ฌ
- min heap
- max heap
- ์ต์, ์ต๋ ๊ฐ์ ๋น ๋ฅด๊ฒ ์ป๊ธฐ ์ํ ์๋ฃ ๊ตฌ์กฐ
- ํธ๋ฆฌ์์์ ์ํ

- Pre-Order Traversal (์ ์ ์ํ)
- Root Node, Left Node, Right Node
- In-Order Traversal (์ค์ ์ํ)
- Left Node, Root Node, Right Node
- Post-Order Traversal (ํ์ ์ํ)
- Left Node, Right Node, Root Node
-
๊ณ ๊ธ
- ํธ๋ผ์ด(trie)
- ํ์ ํธ๋ฆฌ(Fenwick trees, Binary Indexed Trees)
- ์ธ๊ทธ๋จผํธ ํธ๋ฆฌ(Segment trees)
- Red-Black trees
- AVL
- B-trees
- B+trees
- โฆ
-
Shortest Path

- dijkstra
- bellman-ford
- floyd-warshall
- A-star (A*)
- โฆ
-
Minimum Spanning Tree (MST)
- ์ ๊ตญ์ ์ธํฐ๋ท ๋ง์ ์ต์๋น์ฉ์ผ๋ก ๊น๊ณ ์ถ๋ค!



- Prim
- Kruskal
-
topological sorting (์์ ์ ๋ ฌ)
- ๋ฐฉํฅ ๊ทธ๋ํ(DAG, Directed Acyclic Graph)์ ๋ชจ๋ ๋ ธ๋๋ฅผ ์ ํ ๊ด๊ณ๋ฅผ ๋ง์กฑํ๋๋ก ์ผ๋ ฌ๋ก ๋์ดํ๋ ๊ฒ
- ํ ํฌ ํธ๋ฆฌ, ์คํฌ ํธ๋ฆฌ
- ์๊ฐ ๋น์
1๋ฒ ์์ ์ ๋ฃ๊ธฐ ์ํด ์ ํ ์์4or3๊ฐ ํ์ํ๋ค- ์ด๋ ์์ ๋ถํฐ ๋ค์ด์ผ ์์ ์ ๋ค ๋ค์ ์ ์๋์ง


์๊ณ ๋ฆฌ์ฆ ํ ํฌ๋
- math
- implementation
- sorting
- searching
- brute force
- backtracking
- greedy
- divide and conquer
- recursion
- dynamic programming
- two pointer
- sliding window
- dfs
- bfs
- prefix sum array
- imos method
- shortest path












