๋น ์ค(Big O) ํ๊ธฐ๋ฒ์ด ๋ญ๊น? ์ด๋ป๊ฒ ๋ณด๋ ๊ฑฐ์ง?
๐ ๋ค์ด๊ฐ๋ฉฐ
์๊ณ ๋ฆฌ์ฆ, ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ณต๋ถํ๋ ๋ฐ์ ์์ด์ ์๊พธ ๋น ์ค(Big O), ๋น ์ค(Big O) ๊ฑฐ๋ฆฌ๋๋ฐ ๋๋์ฒด ๋น ์ค(Big O)๊ฐ ๋ญ๊ณ ์ ์ฌ์ฉํ๋ ๊ฑด์ง ๋ชฐ๋ผ์ ๊ณต๋ถํ ๋ด์ฉ์ ์ ๋ฆฌํ๊ฒ ๋๋ค.
1. ๋น ์ค(Big O) ํ๊ธฐ๋ฒ์ ์ ์ฌ์ฉํ๋ ๊ฑฐ์ง?
๋จผ์ ๋น ์ค(Big O) ํ๊ธฐ๋ฒ์ ์ ์ฌ์ฉํ๋ ๊ฑธ๊น.
์๋ฃ๊ตฌ์กฐ, ์๊ณ ๋ฆฌ์ฆ ํด๊ฒฐ์ ์์ด์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ ๋ฐฉ๋ฒ์ด ์ฌ๋ฌ ๊ฐ์ง์ธ ๊ฒฝ์ฐ๊ฐ ๋๋ค์์ด๋ค.
์ ์ n์ ๋ฐ์ผ๋ฉด 1๋ถํฐ n๊น์ง์ ํฉ์ ๊ตฌํ๋ ๋ ๊ฐ์ง์ ์ฝ๋๋ฅผ ์๋ก ๋ค์ด๋ณด๊ฒ ๋ค.
์ฒซ ๋ฒ์งธ ์ฝ๋
function addUpTo(n) {
let total = 0;
for (let i = 1; i <= n; i++) {
total += i;
}
return total;
}
๋ ๋ฒ์งธ ์ฝ๋
function addUpTo2(n) {
return n * (n + 1) / 2;
}
์ฒซ ๋ฒ์งธ ์ฝ๋๋ ๋ฐ๋ณต๋ฌธ์ ์ด์ฉํด์ 1๋ถํฐ n๊น์ง์ ์ซ์๋ฅผ ๋ํด์ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ด๊ณ ,
๋ ๋ฒ์งธ ์ฝ๋๋ ์ํ์ ์ธ ๊ณต์์ ์ด์ฉํด์ 1๋ถํฐ n๊น์ง ์ซ์์ ํฉ์ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ด๋ค.
๋ ์ฝ๋์ ๊ฒฐ๊ณผ๋ ๊ฐ๊ฒ ๋์จ๋ค.
ํ์ง๋ง ์ด๋ค ๋ฐฉ๋ฒ์ด ๋ ์ข๊ณ ๋ ๋์ ๋ฐฉ๋ฒ์ธ์ง ์ ์ ์๋ค.
๊ทธ๋์ ์ด๊ฒ์ ํ๋ณํ๊ธฐ ์ํด์ ๋น ์ค(Big O) ํ๊ธฐ๋ฒ์ ์ฌ์ฉํ๋ค.
์ด๋ ๊ฒ ์ผ๋ฐ์ ์ผ๋ก ์๋ก ๋น๊ตํ๊ณ ์ฑ๋ฅ์ ํ๊ฐํ๊ณ ๋น๊ตํ ์ ์๋ ๋ชฉ์ ์ ๊ฐ์ง๊ณ ์๋ ๊ฒ์ด ๋น ์ค(Big O) ํ๊ธฐ๋ฒ์ด๋ผ๊ณ ํ๋ค.
"์ข์ ์ฝ๋", "๋์ ์ฝ๋", "๊ทธ๋ฅ์ ๋ฅ์ธ ์ฝ๋"๋ฅผ ์ซ์๋ก ์ฝ๋์ ์ฑ๋ฅ์ ํ๊ธฐํ ์ ์๋ ๊ฒ์ด๋ค.
2. ๊ทธ๋์ ๋น ์ค(Big O)๋?
์ฆ, ์ ๋ ฅ๊ฐ๊ณผ ์ฐ์ฐ ์ํ ์๊ฐ์์ ์๊ด๊ด๊ณ๋ฅผ ๋ํ๋ด๋ ์ฒ๋๋ฅผ ์๊ฐ ๋ณต์ก๋๋ผ๊ณ ํ๊ณ ์ด๋ฅผ ๋น ์ค(Big O) ํ๊ธฐ๋ฒ์ผ๋ก ํ๊ธฐํ๋ค. ๋ฌผ๋ก ๊ณต๊ฐ ๋ณต์ก๋์ ๋ํด์๋ ์ฌ์ฉ๋ ์ ์๋ค.
์ ๋ ฅ๋ ๊ฐ์ด ์ปค์ง์๋ก ์๊ณ ๋ฆฌ์ฆ ์คํ์๊ฐ์ด ์ด๋ป๊ฒ ๋ณํ๋์ง ์ค๋ช ํ๋ ๊ณต์์ ์ธ ๋ฐฉ๋ฒ.
์๊ฐ ๋ณต์ก๋, ๊ณต๊ฐ ๋ณต์ก๋๋ฅผ ์ฝ๊ฒ ๋ณผ ์ ์๊ฒ ํ๊ธฐํ๋ ๋ํ์ ์ธ ๋ฐฉ๋ฒ ๋น ์ค(Big O)๋ค.
3. ๋น ์ค(Big O) ํ๊ธฐ๋ฒ์ ์ด๋ป๊ฒ ํ๊ธฐํ ์ ์๋ ๊ฑธ๊น?
๋ณดํต ์ฌ์ฉํ๋ ํ๊ธฐ๋ฒ์ผ๋ก๋
O(1), O(log n), O(n), O(n^2), O(n log n), O(2^n) ๋ฑ๋ฑ ์๋ค.
๊ทธ๋ผ ์ด ํ๊ธฐ๋ฒ์ ์ด๋ป๊ฒ ์๊ณ ํ๊ธฐ๋ฅผ ํ๋ ๊ฒ์ผ๊น.
๋ช ๊ฐ์ง ์๋ฅผ ๋ค๋ฉด์ ์์๋ณด์.
3-1 O(1)
function addUpTo2(n) {
return n * (n + 1) / 2;
}
์ ๋ ฅ๊ฐ n์ด ์ปค์ง์๋ก ์ฝ๊ฐ์ ๋ณ๋์ ์์ ์ ์์ง๋ง ์ ๋ฐ์ ์ธ ์ฃผ์ ์๋ ๋ณํ๊ฐ ์๋ค.
10์ผ๋ก ๊ณ์ฐํ๋์ง 10000์ผ๋ก ๊ณ์ฐํ๋์ง ์ฐ์ฐํ๋ ์(์ฝ๋์์์ ๊ณฑ์ , ๋ง์ , ๋๋์ )๋ ๋ณํ์ง ์๊ธฐ ๋๋ฌธ์
O(1)๋ก ํ๊ธฐํ๋ค.
3-2 O(n)
function addUpTo(n) {
let total = 0;
for (let i = 1; i <= n; i++) {
total += i;
}
return total;
}
๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ ์ ๋ ฅ๊ฐ n์ด ์ปค์ง์๋ก ์ฐ์ฐ์ ํ๋ ํ์๋ n์ ํฌ๊ธฐ์ ๋ฐ๋ผ์ ๋ณํ๊ฒ ๋๋ค.
๋ฐ๋ณต๋ฌธ์์ ๋ณด๋ฉด i์ n์ ๋น๊ตํ๊ณ , i๋ฅผ ์ฆ๊ฐ์ํค๊ณ , ๋ณ์ total์ ๋ํด์ฃผ๊ณ ํ๊ณ ์๋๋ฐ,
n์ด 10์ด๋ฉด ์ด ์ฐ์ฐ๋ค์ 10๋ฒ ๋ ๋ฐ๋ณตํ๊ฒ ๋๋ ๊ฒ์ด๊ณ 10,000๋ฒ์ด๋ฉด ์ด ์ฐ์ฐ๋ค์ 10,000๋ฒ ๋ ๋ฐ๋ณตํ๊ฒ ๋๋ค.
n์ ํฌ๊ธฐ์ ๋ฐ๋ผ์ ์๊ฐ์ด ๋ฌ๋ผ์ง๊ฒ ๋๊ธฐ ๋๋ฌธ์ O(n)์ผ๋ก ํ๊ธฐํ๋ค.
๋น ์ค(Big O)๋ ๋ํ ์ผํ ๊ฒ์ ์ ๊ฒฝ ์ฐ์ง ์๊ณ ๊ด๋ฒ์ํ ๋ถ๋ถ๋ง ๋ณด๋ฉด ๋๋ค.
์ฆ, ๊ด๋ฒ์ํ ์ถ์ธ๋ง ๋ณด๊ธฐ์๋ ์์๋ ์ ํ ์ค์ํ์ง ์๊ธฐ ๋๋ฌธ์ O(10n) => O(n), O(300) => O(1), O(5n^2) => O(n^2) ๋ฑ ์ด๋ฐ ์์ผ๋ก ํ๊ธฐํ๋ ๊ฒ์ด๋ค.
3-3 ๊ณ์ฐ ๋ฐฉ๋ฒ
๊ฐ๋จํ๊ฒ ๋งํ๋ฉด ์ฐ์ฐ์ด ๋ช ๋ฒ ์ํ๋๋์ง, ์ ๋ ฅ ๊ฐ๊ณผ ์ฐ์ฐ์ ๊ด๊ณ๊ฐ ์ด๋ป๊ฒ ๋๋์ง ๋ณด๋ฉด ์ฝ๊ฒ ์ ์ ์๋ค.
4. ๋น ์ค(Big O) ํ๊ธฐ๋ฒ์ ์ข ๋ฅ๋?
O(1): ์ ๋ ฅ๊ฐ์ด ํฌ๊ธฐ์ ๋ง์ ์ฐจ์ด๊ฐ ์์ด๋ ์ผ์ ํ ์คํ์๊ฐ์ ๋ณด์ฌ์ฃผ๋ ์ต๊ณ ์ ์๊ณ ๋ฆฌ์ฆ์ด๋ผ๊ณ ํ ์ ์๋ค.
O(log n): ๋ก๊ทธ๋ ์ ๋ ฅ๊ฐ์ด ๋งค์ฐ ์ปค๋ ํฌ๊ฒ ์ํฅ์ ๋ฐ์ง ์๋ ์๊ณ ๋ฆฌ์ฆ์ ํด๋น๋๋ค.
O(n): ์ ๋ ฅ๊ฐ๊ณผ ์๊ณ ๋ฆฌ์ฆ ์ํ์๊ฐ์ด ๋น๋กํ๋ค.
O(n log n): ๋ณํฉ ์ ๋ ฌ ๊ฐ์ ํจ์จ์ด ์ข์ ์๊ณ ๋ฆฌ์ฆ์ด ๋๋ถ๋ถ ์ด์ ํด๋น๋๋ค.
O(n^2): ์ค์ฒฉ, ๋ฒ๋ธ ์ ๋ ฌ ๊ฐ์ ๋น ํจ์จ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
O(2^n): ํผ๋ณด๋์น์ ์๋ฅผ ์ฌ๊ทํจ์๋ก ๊ณ์ฐํ๋ ์๊ณ ๋ฆฌ์ฆ์ ํด๋น๋๋ค.
O(n!): ๋งค์ฐ ๋๋ฆฌ๊ณ ์ ๋ ฅ๊ฐ์ด ์์๋ ๊ณ์ฐ ์๋๊ฐ ๋งค์ฐ ์ฆ๊ฐํ๋ค.
์ ๋ ฅ N๊ฐ์ ๋ฐ๋ฅธ ์๊ณ ๋ฆฌ์ฆ ์๊ฐ ๋ณต์ก๋
๐๋ง์น๋ฉฐ
๋น ์ค(Big O) ํ๊ธฐ๋ฒ์ด ๋ฌด์์ธ์ง, ์ด๋ป๊ฒ ํ๊ธฐํ๋ ๊ฑด์ง ๋ฑ ๋ฐฐ์ด ๋ด์ฉ์ ๊ฐ๋จํ๊ฒ ์ ๋ฆฌํด ๋ดค๋ค.