์๊ณ ๋ฆฌ์ฆ ์ค๊ณ ๋ฐ ์ค์ต
Chap1 1.2 The Importance of Developing Efficient Algorithms
๋ฐ๋ถ์ฅ
2025. 4. 4. 22:50
์ ํจ์จ์ฑ์ด ์ค์ํ๊ฐ?
โ "์ปดํจํฐ ์ฑ๋ฅ์ด ๊ณ์ ์ข์์ง๋๋ฐ ๊ตณ์ด ์๊ณ ๋ฆฌ์ฆ ํจ์จ์ฑ์ ๋ฐ์ ธ์ผ ํด?"
→ Yes. ๋ฌด์กฐ๊ฑด ์ค์ํจ.
- ์ปดํจํฐ๊ฐ ๋นจ๋ผ์ ธ๋, ๋ฌธ์ ํฌ๊ธฐ(input size) ๋ ๋ ๋น ๋ฅด๊ฒ ์ปค์ง
- ์ข์ ์๊ณ ๋ฆฌ์ฆ์ ์์ญ ๋ฐฐ, ์๋ฐฑ ๋ฐฐ ๋น ๋ฅธ ์ฑ๋ฅ ์ฐจ์ด๋ฅผ ๋ง๋ฆ
๐ ๋ ์๊ณ ๋ฆฌ์ฆ ๋น๊ต ์ฌ๋ก
๐น 1.2.1 Sequential Search vs Binary Search
๐งช ๋ฌธ์ : ์ ๋ ฌ๋ ๋ฐฐ์ด์์ x๊ฐ ์๋์ง ์ฐพ๊ธฐ
์๊ณ ๋ฆฌ์ฆ | ๋ฐฉ์ | ๋น๊ต ํ์(์ต์ ์ ๊ฒฝ์ฐ) |
Sequential Search | ์ฒ์๋ถํฐ ๋๊น์ง ์์๋๋ก ๋น๊ต | nํ |
Binary Search | ์ค๊ฐ๊ฐ ๊ธฐ์ค์ผ๋ก ์ ๋ฐ์ฉ ์ค์ฌ๊ฐ | logโn + 1ํ |
๐ ํต์ฌ ๋น๊ต
- n = 4,294,967,296์ผ ๊ฒฝ์ฐ:
- Sequential: ์ฝ 43์ต ๋ฒ ๋น๊ต
- Binary: ๋จ 33๋ฒ๋ง ๋น๊ต
์๋ฌด๋ฆฌ ์ปดํจํฐ๊ฐ ๋นจ๋ผ๋ Sequential์ ์ ์ด, Binary๋ ๊ฑฐ์ ์ฆ์ ๊ฒฐ๊ณผ!
๋ฌธ์ ์ํฉ
๋ชฉํ: ์ ๋ ฌ๋ ๋ฐฐ์ด S[1..n] ์์์ ์์ x๋ฅผ ์ฐพ๊ธฐ
→ x์ ์์น(index)๋ฅผ ๋ฐํํ๊ฑฐ๋, ์์ผ๋ฉด 0
๐ด Sequential Search (์ ํ ํ์)
procedure SequentialSearch(S[1..n], x)
for i = 1 to n
if S[i] == x then return i
return 0
ํน์ง:
- ์์์๋ถํฐ ํ๋์ฉ ์์ฐจ์ ์ผ๋ก ๋น๊ต
- ๋ฐฐ์ด์ด ์ ๋ ฌ๋์ด ์์ง ์์๋ ๊ฐ๋ฅ
- ์ต์ ์ ๊ฒฝ์ฐ: ๋๊น์ง ๋น๊ต → n๋ฒ
์๊ฐ๋ณต์ก๋:
- ์ต์ : O(1)
- ํ๊ท : O(n/2)
- ์ต์ : O(n)
โ Binary Search (์ด์ง ํ์)
๐ ๊ธฐ๋ณธ ๊ฐ๋
- ์ค๊ฐ ๊ฐ(mid)์ ์ ํํด์ x์ ๋น๊ต
- ๊ฐ์ผ๋ฉด ์ฐพ์ ๊ฒ → ๋ฐํ
- x๊ฐ ๋ ์์ผ๋ฉด → ์ผ์ชฝ ์ ๋ฐ๋ง ํ์
- x๊ฐ ๋ ํฌ๋ฉด → ์ค๋ฅธ์ชฝ ์ ๋ฐ๋ง ํ์
- ๋ฐ๋ณต
๐ฆ ์ฌ์ฉ ๋ณ์
๋ณ์ | ์๋ฏธ |
low | ํ์ฌ ํ์ ๋ฒ์์ ์์ ์ธ๋ฑ์ค |
high | ํ์ฌ ํ์ ๋ฒ์์ ๋ ์ธ๋ฑ์ค |
mid | ์ค๊ฐ ์์น ์ธ๋ฑ์ค ((low + high) // 2) |
procedure BinarySearch(S[1..n], x)
low ← 1
high ← n
while low ≤ high
mid ← ⌊(low + high)/2⌋
if S[mid] == x then return mid
else if x < S[mid] then high ← mid - 1
else low ← mid + 1
return 0
ํน์ง:
- ์ ๋ ฌ๋ ๋ฐฐ์ด์์๋ง ์ฌ์ฉ ๊ฐ๋ฅ
- ๋งค ๋จ๊ณ๋ง๋ค ํ์ ๋ฒ์๋ฅผ ์ ๋ฐ์ผ๋ก ์ค์
- ๋งค์ฐ ๋น ๋ฆ! (๋ก๊ทธ ์๊ฐ)
์๊ฐ๋ณต์ก๋:
- ํญ์ O(logโn) (์ฝ๊ฐ์ ์์ ์ฐจ์ด๋ก +1 ํฌํจ)
โ ์ํ ๋๋น ์ฒดํฌ ํฌ์ธํธ
์ง๋ฌธ | ๋ต๋ณ ์์ฝ |
Binary Search์ ์ ์ ์กฐ๊ฑด์? | ๋ฐฐ์ด์ด ์ ๋ ฌ๋์ด ์์ด์ผ ํจ |
์ logโn๋งํผ ๋น ๋ฅธ๊ฐ? | ๋งค๋ฒ ๋ฒ์๋ฅผ ์ ๋ฐ์ฉ ์ค์ด๊ธฐ ๋๋ฌธ |
Binary Search ์๊ฐ๋ณต์ก๋๋? | O(log n) |
Sequential Search์์ ์ฐจ์ด๋? | Binary๋ ํจ์ฌ ๋ ์ ์ ๋น๊ต ํ์๋ก ํ์ ๊ฐ๋ฅ |
๐น 1.2.2 ํผ๋ณด๋์น ์์ด ์๊ณ ๋ฆฌ์ฆ ๋น๊ต
๐ ๋ฌธ์ : n๋ฒ์งธ ํผ๋ณด๋์น ์๋ฅผ ๊ตฌํ๋ผ
๐จ ๋นํจ์จ์ : Algorithm 1.6 (์ฌ๊ท recursive)
function fib(n)
if n == 0 or n == 1 then
return n
return fib(n-1) + fib(n-2)
- ๊ฐ์ ๊ฐ์ ์ฌ๋ฌ ๋ฒ ๋ฐ๋ณต ๊ณ์ฐ
- ๊ณ์ฐ๋์ด 2^(n/2) ์ด์ → ์ง์์ ์ฆ๊ฐ
- ์: n=120์ด๋ฉด ์์ญ ๋ ์ด์ ๊ฑธ๋ฆด ์๋ ์์ (!)
ํจ์จ์ : Algorithm 1.7 (๋ฐ๋ณต Iterative)
function fib2(n)
f[0] ← 0
f[1] ← 1
for i = 2 to n
f[i] ← f[i-1] + f[i-2]
return f[n]
- ๋ชจ๋ ํญ์ ํ ๋ฒ๋ง ๊ณ์ฐ → O(n) ์๊ฐ
- n=120๋ ์์๊ฐ์ ๊ณ์ฐ
๐ก ๊ฒฐ๋ก : ์๊ณ ๋ฆฌ์ฆ ์ ํ์ด ์๋ช ์ด๋ค!
์๊ณ ๋ฆฌ์ฆ | ์๊ฐ๋ณต์ก๋ | ์คํ ์๊ฐ |
์ฌ๊ท ํผ๋ณด๋์น | O(2^n) | ์์ญ ๋ |
๋ฐ๋ณต ํผ๋ณด๋์น | O(n) | 0.0000001์ด ์์ค |
๐ฏ ํต์ฌ ํค์๋ ์์ฝ
- ํจ์จ์ฑ์ ๋ฌธ์ ํฌ๊ธฐ๊ฐ ์ปค์ง์๋ก ํ์
- ๋นํจ์จ ์๊ณ ๋ฆฌ์ฆ์ ์๋ฌด๋ฆฌ ์ข์ ์ปดํจํฐ๋ ์์ฉ ์์
- ์ด๋ก ์ ๋ถ์์ ์ค์ ์ฑ๋ฅ์ ํฐ ์ํฅ์ ์ค
- ์ข์ ์ค๊ณ = ์์ฒ ๋ฐฐ ์ด์์ ์คํ ์๊ฐ ์ ์ฝ
๐ ์ํ ๋๋น ์ฒดํฌ ํฌ์ธํธ
์ง๋ฌธ | ๋ต๋ณ ์์ฝ |
์ ํจ์จ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ด ์ค์ํ๊ฐ? | ๋ฌธ์ ํฌ๊ธฐ๊ฐ ์ปค์ง๋ฉด, ๋นํจ์จ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ ํ์ค์ ์ผ๋ก ์ฌ์ฉ ๋ถ๊ฐ |
Binary Search๊ฐ ๋น ๋ฅธ ์ด์ ๋? | ๋งค๋ฒ ๊ฒ์ ๋ฒ์๋ฅผ ์ ๋ฐ์ผ๋ก ์ค์ด๊ธฐ ๋๋ฌธ |
์ฌ๊ท ํผ๋ณด๋์น๊ฐ ๋๋ฆฐ ์ด์ ๋? | ์ค๋ณต ๊ณ์ฐ์ด ๋๋ฌด ๋ง์์ ๊ณ์ฐ๋์ด ์ง์์ ์ผ๋ก ์ฆ๊ฐ |
ํจ์จ์ ์ธ ํผ๋ณด๋์น ๊ณ์ฐ๋ฒ์? | ๋ฐ๋ณต๋ฌธ์ผ๋ก ๊ณ์ฐ + ์ด์ ๋ ํญ๋ง ๊ธฐ์ต → O(n) |
[์ฐธ๊ณ ์ฌํญ]
๐งฎ ํผ๋ณด๋์น ์์ด (Fibonacci Sequence)
์ ์
ํผ๋ณด๋์น ์์ด์ ๋ค์๊ณผ ๊ฐ์ ์ ํ์(์ฌ๊ท์)์ผ๋ก ์ ์๋๋ค:
F(0)=0,F(1)=1F(n)=F(n−1)+F(n−2),n≥2
์ฆ, ์ด์ ๋ ํญ์ ๋ํด์ ๋ค์ ํญ์ ๋ง๋๋ ์์ด์ด๋ค.
โถ๏ธ ์ฒ์ ๋ช ๊ฐ ํญ์?
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55,...