1. ๋์ ๋ฐฐ์ด
- ๋ชจ๋ ์ธ์ด์์ ์ฌ์ฉ๋๋ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ์๋ฃ๊ตฌ์กฐ
- ์ฌ๋ฌ ๋ฐ์ดํฐ๋ฅผ ํ ๊ณณ์ ์ ์ฅํ ๋ ๊ฐ์ฅ ๋จผ์ ๊ณ ๋ ค
Memory Structure
-
os๋ ํ๋ก๊ทธ๋จ์ ์คํ์ ์ํด ๋ค์ํ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ ์ ๊ณต ์ค
- Stack
- ํจ์์ ํธ์ถ๊ณผ ๊ด๊ณ๋๋ ์ง์ญ ๋ณ์์ ๋งค๊ฐ๋ณ์ ์ ์ฅ๋๋ ์์ญ
- ์คํ ์์ญ์ ํจ์์ ํธ์ถ๊ณผ ํจ๊ป ํ ๋น๋๋ฉฐ, ํจ์์ ํธ์ถ์ด ์๋ฃ๋๋ฉด ์๋ฉธ
- ๋งค์ฐ ๋น ๋ฅธ ์ก์ธ์ค์ ๋ณ์์ ๋ช ์์ ํ ๋นํด์ ๋ถํ์
- ๋ณ์์ ํฌ๊ธฐ ์กฐ์ ๋ถ๊ฐ
- Heap
- ์ฌ์ฉ์๊ฐ ์ง์ ๊ด๋ฆฌํ๋ ๋ฉ๋ชจ๋ฆฌ ์์ญ
- ์ฌ์ฉ์์ ์ํด ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ด ๋์ ์ผ๋ก ํ ๋น๋๊ณ ํด์
- ๋ฉ๋ชจ๋ฆฌ ํฌ๊ธฐ ์ ํ ์์
- ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ด๋ฆฌํด์ผํจ (๋ณ์๋ฅผ ์ง์ ํ ๋นํ๊ณ ํด์ ํด์ผ ํจ)
- ํ ์์ญ์ ์ ์ฅ๋๋ ๋ฐฐ์ด -> Dynamic array
- Python: List
- C++: vector
- Java: ArrayList
Abstract Data Type
1) is_empty()
- ํ์ด์ฌ์์ ๋น ๋ฆฌ์คํธ๋ ๊ฑฐ์ง์ ์๋ฏธ
test = []
print(bool(test))
False
2) append(element)
- append() ๋ฉ์๋๊ฐ ๋ฆฌ์คํธ์ ๋ง์ง๋ง์ ์์๋ฅผ ์ถ๊ฐํ๋ ์ฐ์ฐ ์ํ
test = [1,2,3,4,5,6]
test.append(7)
print(test)
[1, 2, 3, 4, 5, 6, 7]
3) insert(index, element)
- insert() ๋ฉ์๋๊ฐ ๋ฆฌ์คํธ์ ์ค๊ฐ์ ์์๋ฅผ ์ถ๊ฐํ๋ ์ฐ์ฐ
test = [1,2,3,5]
test.insert(1,4)
print(test)
[1, 4, 2, 3, 5]
4) remove_last()
- pop() ๋ฉ์๋์ ํ๋ผ๋ฏธํฐ ์ ๋ฌํ์ง ์์ผ๋ฉด ๋ฆฌ์คํธ์ ๋ง์ง๋ง ์์ ์ญ์
test = [1,4,2,3,5]
test.pop()
print(test)
[1, 4, 2, 3]
5) remove(index)
- pop ๋ฉ์๋์ ํ๋ผ๋ฏธํฐ๋ก ์ธ๋ฑ์ค ์ ๋ฌ ์ ๋ฆฌ์คํธ์ ์ธ๋ฑ์ค ์์น์ ์๋ ์์ ์ญ์
test = [1,4,2,3]
test.pop(2)
print(test)
[1, 4, 3]
2. ์ง์ญ์ฑ์ ์๋ฆฌ์ ์บ์
์ง์ญ์ฑ์ ์๋ฆฌ (principle of locality)
- ํ๋ก์ธ์ค ๋ด ๋ช ๋ น์ด ๋ฐ ๋ฐ์ดํฐ์ ๋ํ ์ฐธ์กฐ๊ฐ ๊ตฐ์งํ ๊ฒฝํฅ์ด ์์์ ๋ปํจ
- ๊ณต๊ฐ ์ง์ญ์ฑ (spatial locality)
- ์ด๋ฒ์ ์ ๊ทผํ ๋ณ์๋ ์ด์ ์ ์ ๊ทผํ ๋ณ์ ๊ทผ์ฒ์ ์์ ๊ฐ๋ฅ์ฑ์ด ๋์
โญ๏ธ ๋ฐฐ์ด์ ๋ฉ๋ชจ๋ฆฌ ์์์ ๋ฌผ๋ฆฌ์ , ์ ํ์ ์ผ๋ก ์ด์ด์ ธ ์๋ค. โญ๏ธ
์บ์ (cache)
- ๋ฐ์ดํฐ๋ ๊ฐ์ ๋ฏธ๋ฆฌ ๋ณต์ฌํด ๋๋ ์์ ์ฅ์
- ๋ฐฐ์ด ์ค์ ํ element๋ฅผ ๋ฉ๋ชจ๋ฆฌ์๊ฒ ์์ฒญํ ๊ฒฝ์ฐ ๋ฐฐ์ด์ด ํต์ผ๋ก ์บ์์ ์ฌ๋ผ๊ฐ๋ค.
- ์ง์ญ์ฑ์ ์๋ฆฌ๋ก ๋ฐฐ์ด์ ํ element๊ฐ ์์ฒญ ๋ ๊ฒฝ์ฐ ๋ค๋ฅธ element๋ค๋ ์์ฒญ๋ ํ๋ฅ ์ด ๋๋ค.
- ์ด ๋ ๋ค๋ฅธ element๊ฐ ์์ฒญ๋ ๊ฒฝ์ฐ ์บ์์์ ๊ฐ์ ธ์ค๋ฉด ๋จ
- ๋ฉ๋ชจ๋ฆฌ์์ ๋ฐ์ดํฐ ๊ฐ์ ธ ์ฌ ๋ 20 ~100 ํด๋ญ ์์
- ์บ์์์ ๋ฐ์ดํฐ ๊ฐ์ ธ์ฌ ๋ 3ํด๋ญ ์์
- ์ฑ๋ฅ์ ์๋ฑํ๊ฒ ํฅ์
3. ์ธ๋ฑ์ฑ (Indexing)
- ์ธ๋ฑ์ค: ๋ฆฌ์คํธ์์ element์ ์์น
- ์ธ๋ฑ์ฑ: ํน์ ์์น์ element๋ฅผ ๊ฐ์ ธ์ค๋ ๊ฒ
- ๋ฐ์ดํฐ ์ฃผ์ ๊ฐ = ๋ฐฐ์ด์ ์ฒซ ์ฃผ์ ๊ฐ + (๋ฐ์ดํฐ ํฌ๊ธฐ * ์ธ๋ฑ์ค)
- ํ ๋ฒ์ ์ฐ์ฐ์ผ๋ก๋ ๊ฐ์ ์ ๊ทผ ๊ฐ๋ฅ -> O(1)
- ๋ฐ์ดํฐ์ ๊ฐ์ ์๊ด ์์
๋น ์ค ํ๊ธฐ๋ฒ
n = 10
result = 0
for i in range(1, n+1):
for j in range(i):
result += 1
print(result)
-> n(n+1)/2 ๋ฒ ๊ณ์ฐ : O(n^2)
n = 10
result = 0
for i in range(1, n+1):
result += i
print(result)
-> n๋ฒ ๊ณ์ฐ : O(n)
n = 10
result = n*(n+1)/2
print(result)
-> 1๋ฒ ๊ณ์ฐ : O(1)
- ์ ์ฝ๋ ๋ค์ n์ ๊ฐ์ด ์๋ค๋ฉด ํฐ ์ฐจ์ด ์๊ฒ ๋๊ปด์ง์ง๋ง n์ ๊ฐ์ด ์ปค์ง๋ค๋ฉด ํจ์จ์ฑ์ ์ฐจ์ด๊ฐ ์ปค์ง๋ค
4. ๋ฐ์ดํฐ ์ฝ์ , ์ญ์
- capacity : ๋ฐฐ์ด์ด ํ๋ณดํ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ
- size: ์ฑ์์ง ๋ฐ์ดํฐ ํฌ๊ธฐ
1) ๋ฐฐ์ด ๋งจ ๋ง์ง๋ง์ ์ถ๊ฐ
- Capacity๊ฐ size๋ณด๋ค ํฐ ๊ฒฝ์ฐ
- ๋จ์ํ ๋ง์ง๋ง ์์ ๋ค์์ ์๋ก์ด ์์ ์ถ๊ฐํ๋ฉด ๋จ : O(1)
- ๋ฐฐ์ด์ด ๊ฐ๋ ์ฐจ์๋ ๊ฒฝ์ฐ
- ์ถฉ๋ถํ ๊ณต๊ฐ ๋ค์ ํ๋ณด ํ ๊ธฐ์กด ๋ฐฐ์ด์์๋ฅผ ๋ชจ๋ ๋ณต์ฌํ ํ ์๋ก์ด ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํด์ผ ํจ.
- ๋ฐ์ดํฐ ๊ฐ์๋งํผ ๋ณต์ฌํด์ผ ํ๋ฏ๋ก O(n)
- capacity๊ฐ ์ถฉ๋ถํ ์ปค์ ์ถ๊ฐํ๋ ๋์์ O(1)์ด์ง๋ง ๋ฐฐ์ด์ด ๊ฝ ์ฐผ์ ๋ ํ๋ฒ O(n)
- ๋์ ๋ฐฐ์ด์์ ๋ฐฐ์ด์ด ๊ฐ๋ ์ฐผ์ ๋ ๋ฐฐ์ด ํฌ๊ธฐ์ 2๋ฐฐ๋งํผ capacity ์ก์
2) ๋ฐฐ์ด ๋งจ ๋ง์ง๋ง ์ญ์
- ๋ฐฐ์ด์ ๋งจ ๋ง์ง๋ง ์์๋ง ์ญ์
- ๋ฉ๋ชจ๋ฆฌ๋ฅผ 0์ผ๋ก ์ด๊ธฐํ ํ ํ์ ์๊ณ ์์๋ง ์ญ์ ํด๋ ๋ฉ๋ชจ๋ฆฌ ํด์
- O(1)
3) ๋ฐฐ์ด ์ค๊ฐ์ ๋ฐ์ดํฐ ์ถ๊ฐ
- ์ด๋ฏธ ์๋ ์์๋ฅผ ๋ชจ๋ ํ ๋ฒ ์ฉ ๋ค๋ก ์ฎ๊น
- ๊ทธ ํ ๋น ์๋ฆฌ์ ์๋ก์ด ์์ ์ฝ์
- ๋ฐ์ดํฐ ๊ฐ์๊ฐ n์ด๋ผ๋ฉด ์ต์ ์ ๊ฒฝ์ฐ ๋งจ์์ ์ถ๊ฐํด์ผ ํ๋ฏ๋ก O(n)
## 4) ๋ฐฐ์ด ์ค๊ฐ์ ๋ฐ์ดํฐ ์ญ์
- ๋งจ ์์ ๋ฐ์ดํฐ (4)๋ฅผ ์ญ์ ํ๋ ค๋ฉด ๋ค์ ์๋ ๋ฐ์ดํฐ ํ ์นธ์ฉ ์์ผ๋ก ์ฎ๊ฒจ์ผ ํจ
- O(n)