let's get IT with DAVINA ๐ป
์๊ณ ๋ฆฌ์ฆ/์๊ฐ ๋ณต์ก๋ ๋ณธ๋ฌธ
์๊ฐ ๋ณต์ก๋ (Time Complextity)
- ์ ๋ ฅ๊ฐ์ด ์ปค์ง์ ๋ฐ๋ผ ์ฆ๊ฐํ๋ ์๊ฐ์ ๋น์จ์ ์ต์ํํ ์๊ณ ๋ฆฌ์ฆ
- ์ ๋ ฅ์ ํฌ๊ธฐ์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ์๊ด๊ด๊ณ
Big-O ํ๊ธฐ๋ฒ
- ์ฃผ์ด์ง ์์ ๊ฐ์ด ๊ฐ์ฅ ํฐ ๋ํํญ๋ง ๋จ๊ฒจ์ ๋ํ๋ด๋ ๋ฐฉ๋ฒ
- Big-O(๋น
-์ค)
- ์ต์ ์ ๊ฒฝ์ฐ
- ํ๋ก๊ทธ๋จ์ด ์คํ๋๋ ๊ณผ์ ์์ “์ด ์ ๋ ์๊ฐ๊น์ง ๊ฑธ๋ฆด ์ ์๋ค”๋ฅผ ๊ณ ๋ คํด์ผ ํ๋ค!
- Big-Ω(๋น
-์ค๋ฉ๊ฐ)
- ์ต์ ์ ๊ฒฝ์ฐ
- Big-θ(๋น
-์ธํ)
- ์ค๊ฐ(ํ๊ท )์ ๊ฒฝ์ฐ
O(1)
- constant complexity
- ์ ๋ ฅ๊ฐ์ด ์ฆ๊ฐํ๋๋ผ๋ ์๊ฐ์ด ๋์ด๋์ง ์๋๋ค.
- ์ ๋ ฅ๊ฐ์ ํฌ๊ธฐ์ ๊ด๊ณ์์ด, ์ฆ์ ์ถ๋ ฅ๊ฐ์ ์ป์ด๋ผ ์ ์๋ค.
function O_1_algorithm(arr, index) {
return arr[index];
}
let arr = [1, 2, 3, 4, 5];
let index = 1;
let result = O_1_algorithm(arr, index);
console.log(result); // 2 (arr์ ๊ธธ์ด๊ฐ 100์ด๋ผ๋ ์ฆ์ index๋ฅผ ํตํด ๊ฐ ๋ฐํ ๊ฐ๋ฅ)
O(n)
- linear complexity
- ์ ๋ ฅ๊ฐ์ด ์ฆ๊ฐํจ์ ๋ฐ๋ผ ์๊ฐ ๋ํ ๊ฐ์ ๋น์จ๋ก ์ฆ๊ฐํ๋ ๊ฒ (n์ ๋น๋กํ๋ค)
//์
๋ ฅ๊ฐ์ด 1์ผ ๋ 1์ด์ ์๊ฐ์ด ๊ฑธ๋ฆฌ๊ณ , ์
๋ ฅ๊ฐ์ 100๋ฐฐ๋ก ์ฆ๊ฐ์์ผฐ์ ๋ 1์ด์ 100๋ฐฐ์ธ 100์ด๊ฐ ๊ฑธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ
function O_n_algorithm(n) {
for (let i = 0; i < n; i++) {
// do something for 1 second
}
}
//์
๋ ฅ๊ฐ์ด 1 ์ฆ๊ฐํ ๋๋ง๋ค ์ฝ๋์ ์คํ ์๊ฐ์ด 2์ด์ฉ ์ฆ๊ฐ (O(2n)์ด์ง๋ง, ๊ฐ์ ๋น์จ๋ก ์ฆ๊ฐํ๊ณ ์๋ค๋ฉด 2๋ฐฐ,5๋ฐฐ,10๋ฐฐ ์ฆ๊ฐํ๋๋ผ๋ ๊ทธ๋๋ก O(n)์ผ๋ก ํ๊ธฐ)
function another_O_n_algorithm(n) {
for (let i = 0; i < 2n; i++) {
// do something for 1 second
}
}
O(log n)
- logarithmic complexity
- O(1) ๋ค์์ผ๋ก ๋น ๋ฅธ ์๊ฐ ๋ณต์ก๋ (log n์ ๋น๋กํ๋ค)
ex) BST์์ ์ํ๋ ๊ฐ์ ํ์ํ ๋, ๋ ธ๋๋ฅผ ์ด๋ํ ๋๋ง๋ค ๊ฒฝ์ฐ์ ์๊ฐ ์ ๋ฐ์ผ๋ก ์ค์ด๋ ๋ค.
1. 1~100 ์ค ํ๋์ ์ซ์๋ฅผ ํ๋ ์ด์ด1์ด ๊ณ ๋ฅธ๋ค (30์ ๊ณจ๋๋ค๊ณ ๊ฐ์ ํฉ๋๋ค).
2. 50(๊ฐ์ด๋ฐ) ์ซ์๋ฅผ ์ ์ํ๋ฉด 50๋ณด๋ค ์์ผ๋ฏ๋ก down์ ์ธ์น๋ค.
3. 1~50์ค์ ํ๋์ ์ซ์์ด๋ฏ๋ก ๋๋ค์ ๊ฒฝ์ฐ์ ์๋ฅผ ์ ๋ฐ์ผ๋ก ์ค์ด๊ธฐ ์ํด 25๋ฅผ ์ ์ํ๋ค.
4. 25๋ณด๋ค ํฌ๋ฏ๋ก up์ ์ธ์น๋ค.
5. ๊ฒฝ์ฐ์ ์๋ฅผ ๊ณ์ ์ ๋ฐ์ผ๋ก ์ค์ฌ๋๊ฐ๋ฉฐ ์ ๋ต์ ์ฐพ๋๋ค. (์ต์ ์ ๊ฒฝ์ฐ์๋ 7๋ฒ์ด๋ฉด ๋ต ์ฐพ๊ธฐ ๊ฐ๋ฅ)
O(n^2)
- quadratic complexity
- ์
๋ ฅ๊ฐ์ด ์ฆ๊ฐํจ์ ๋ฐ๋ผ ์๊ฐ์ด n์ ์ ๊ณฑ์์ ๋น์จ๋ก ์ฆ๊ฐ
- ์ ๋ ฅ๊ฐ์ด 1์ผ๋ 1์ด๊ฐ ๊ฑธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ 5๋ผ๋ ์ ๋ ฅ๊ฐ์ด ์ฃผ์ด์ง๋ฉด 25์ด๊ฐ ๊ฑธ๋ ค์ฉ
function O_quadratic_algorithm(n) {
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
// do something for 1 second
}
}
}
//2n, 5n ์ ๋ชจ๋ O(n)์ด๋ผ๊ณ ํํํ๋ ๊ฒ์ฒ๋ผ, n^3๊ณผ n^5 ๋ ๋ชจ๋ O(n^2)๋ก ํ๊ธฐ
function another_O_quadratic_algorithm(n) {
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
for (let k = 0; k < n; k++) {
// do something for 1 second
}
}
}
}
O(2^n)
- exponential complexity
- ๊ฐ์ฅ ๋๋ฆฐ ์๊ฐ ๋ณต์ก๋
function fibonacci(n) {
if (n <= 1) {
return 1;
}
return fibonacci(n - 1) + fibonacci(n - 2);
}
๋ฐ์ดํฐ ํฌ๊ธฐ์ ๋ฐ๋ฅธ ์๊ฐ ๋ณต์ก๋
N์ ํฌ๊ธฐ | ํ์ฉ ์๊ฐ ๋ณต์ก๋ |
N ≤ 11 | O(N!) |
N ≤ 25 | O(2^N) |
N ≤ 100 | O(N^4) |
N ≤ 500 | O(N^3) |
N ≤ 3,000 | O(N^2lgN) |
N ≤ 5,000 | O(N^2) |
N ≤ 1,000,000 | O(Nlgn) |
N ≤ 10,000,000 | O(N) |
๊ทธ ์ด์ | O(lgN),O(1) |
'DEV_IN > Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๊ณ ๋ฆฌ์ฆ ์ ํ] Greedy Algorithm (2) | 2023.03.07 |
---|---|
์๊ณ ๋ฆฌ์ฆ/๊ณต๊ฐ ๋ณต์ก๋ (2) | 2023.02.24 |
์๊ณ ๋ฆฌ์ฆ์ด๋? (2) | 2023.02.24 |
์๋ฃ๊ตฌ์กฐ/๋น์ ํ๊ตฌ์กฐ/๊ทธ๋ํ (2) | 2023.02.23 |
์๋ฃ๊ตฌ์กฐ/๋น์ ํ๊ตฌ์กฐ/ํธ๋ฆฌ (0) | 2023.02.23 |
Comments