Jieunny์ ๋ธ๋ก๊ทธ
S4) Unit 11. [์๋ฃ๊ตฌ์กฐ/์๊ณ ๋ฆฌ์ฆ] ์๊ณ ๋ฆฌ์ฆ & ์๊ฐ ๋ณต์ก๋ & ๊ณต๊ฐ ๋ณต์ก๋ ๋ณธ๋ฌธ
S4) Unit 11. [์๋ฃ๊ตฌ์กฐ/์๊ณ ๋ฆฌ์ฆ] ์๊ณ ๋ฆฌ์ฆ & ์๊ฐ ๋ณต์ก๋ & ๊ณต๊ฐ ๋ณต์ก๋
Jieunny 2023. 4. 5. 12:00๐ฃ ์๊ณ ๋ฆฌ์ฆ
๐ญ. ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ๋
โ๏ธ ์ด๋ค ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด์ ์ผ๋ จ์ ์ ์ฐจ๋ฅผ ์ ์ํ๊ณ , ๊ณต์ํํ ํํ๋ก ํํํ ์ผ์ข ์ ๋ฌธ์ ํ์ด ๋ฐฉ๋ฒ
โฐ ํ๋ก๊ทธ๋๋ฐ์์๋ input ๊ฐ์ ํตํด output ๊ฐ์ ์ป๊ธฐ ์ํ ๊ณ์ฐ ๊ณผ์ ์ ์๋ฏธ
ใด ์ ๋ ฅ(input) : ์ถ๋ ฅ์ ํ์ํ ์๋ฃ
ใด ์ถ๋ ฅ(output) : ์๊ณ ๋ฆฌ์ฆ์ด ๋์ด ๋ฌ๋ค๋ ์๋ฏธ๋ก ์คํ์ด ๋๋๋ฉด ์ ์ด๋ ํ๊ฐ์ง ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํด์ผ ํ๋ค.
ใด ์ ํ์ฑ(Finiteness) : ์ ํํ ๋ช ๋ น์ด๋ฅผ ์ํํ ํ, ์ ํํ ์๊ฐ ๋ด์ ์ข ๋ฃํด์ผ ํ๋ค.
ใด ๋ช ํ์ฑ(Definiteness) : ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ ๋จ๊ณ๋ ๋จ์ํ๊ณ ๋ช ํํด์ผ ํ๋ฉฐ, ๋ชจํธํด์๋ ์๋๋ค.
ใด ํจ์จ์ฑ(Efficiency) : ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ๋ฅํ ํ ํจ์จ์ ์ด์ด์ผ ํ๋ค.
๐ฎ. ์๊ณ ๋ฆฌ์ฆ์ ์ค์์ฑ
โ๏ธ ์ ์ฐจ๊ฐ ๋ช ํํ๊ฒ ํํ๋์ด ์๊ณ , ํจ์จ์ ์ด๋ฏ๋ก ๋ค์ํ ๋ฌธ์ ํด๊ฒฐ ๊ณผ์ ์์ ๋ํ๋๋ ๋ถํ์ํ ์์ ๋ค์ ์ค์ฌ์ค๋ค.
โฐ ์ ํํ์ง ์์ ๋ต์ ํผ๋์ ์ฃผ๊ณ , ํ๋ก๊ทธ๋๋ฐ ์์ฒด์ ํฐ ๋ฌธ์ ๋ฅผ ์ผ๊ธฐํ๋ฏ๋ก ์ ํํ๊ฒ ์ง๋ ๊ฒ์ด ์ค์ํ๋ค.
๐ฏ. ์๊ณ ๋ฆฌ์ฆ์ ์ ํธ๋ ๋ฐฉ๋ฒ
1๏ธโฃ ๋ฌธ์ ๋ฅผ ์ดํดํ๋ค.
โฐ ์ฃผ์ด์ง ์กฐ๊ฑด์ ํ ๋๋ก ๋ฌธ์ ๊ฐ ๋ฌด์์ธ์ง๋ฅผ ์ดํดํ๋ ๊ฒ๋ถํฐ ์์ํ๋ค.
2๏ธโฃ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ๋ต์ ์ธ์ด๋ค.
โฐ ์๋์ฝ๋๋ถํฐ ์์ฑํด ๋ณธ๋ค.
3๏ธโฃ ์ ๋ต์ ์ฝ๋๋ก ์ฎ๊ฒจ๋ณธ๋ค.
โฐ ์ ๋ต์ ์ฝ๋๋ก ์ฎ๊ธฐ๊ณ , ์ต์ ํ๋ฅผ ์๋ํด๋ณธ๋ค.
๐ฃ ์๊ฐ ๋ณต์ก๋
๐ญ. ์๊ฐ ๋ณต์ก๋
โ๏ธ ์ ๋ ฅ๊ฐ์ ๋ณํ์ ๋ฐ๋ผ ์ฐ์ฐ์ ์คํํ ๋, ์ฐ์ฐ ํ์์ ๋นํด ์๊ฐ์ด ์ผ๋ง๋งํผ ๊ฑธ๋ฆฌ๋๊ฐ?
โฐ ๋น -์ค ํ๊ธฐ๋ฒ์ ์ฌ์ฉํด์ ๋ํ๋ธ๋ค.
๐ฎ. Big-O ํ๊ธฐ๋ฒ
โ๏ธ ์ต์ ์ ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํ๋ ๋ฐฉ๋ฒ์ผ๋ก, ํ๋ก๊ทธ๋จ์ด ์คํ๋๋ ๊ณผ์ ์์ ์์๋๋ ์ต์ ์ ์๊ฐ๊น์ง ๊ณ ๋ คํ ์ ์๋ค.
1๏ธโฃ 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
2๏ธโฃ O(n)
โฐ linear complexity๋ก, ์ ๋ ฅ๊ฐ์ด ์ฆ๊ฐํจ์ ๋ฐ๋ผ ์๊ฐ๋ ๊ฐ์ ๋น์จ๋ก ์ฆ๊ฐํ๋ ๊ฒ์ ์๋ฏธํ๋ค.
function O_n_algorithm(n) {
for (let i = 0; i < n; i++) {
// do something for 1 second
}
}
function another_O_n_algorithm(n) {
for (let i = 0; i < 2n; i++) {
// do something for 1 second
}
}
โฐ ์ ๋ ฅ๊ฐ์ด 1 ์ฆ๊ฐํ ๋ ๋ง๋ค ์คํ ์๊ฐ๋ 1์ด์ฉ ์ฆ๊ฐํ๋ค => ๊ฐ์ ๋น์จ๋ก ์ฆ๊ฐ
โฐ 2n, 5n๋ ๋ชจ๋ O(n)์ผ๋ก ํ๊ธฐํ๋ค.
3๏ธโฃ O(log n)
โฐ logarithmic complexity๋ก, O(1) ๋ค์์ผ๋ก ๋น ๋ฅธ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ค.
โฐ BST ์ฒ๋ผ ์ ๋ ฅ๊ฐ์ด ์ ๋ฐ์ผ๋ก ๊ณ์ ์ค์ด๋๋ ์๊ณ ๋ฆฌ์ฆ์ด ํด๋นํ๋ค.
4๏ธโฃ O(n^2)
โฐ quadratic complexity๋ก, ์ ๋ ฅ๊ฐ์ด ์ฆ๊ฐํจ์ ๋ฐ๋ผ ์๊ฐ์ด n์ ์ ๊ณฑ์์ ๋น์จ๋ก ์ฆ๊ฐํ๋ ๊ฒ์ ์๋ฏธํ๋ค.
function O_quadratic_algorithm(n) {
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
// do something for 1 second
}
}
}
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(n^3), O(n^5)๋ ๋ชจ๋ O(n^2)๋ก ํ๊ธฐํ๋ค.
5๏ธโฃ O(2^n)
โฐ exponential complexity๋ก, Big-O ํ๊ธฐ๋ฒ ์ค ๊ฐ์ฅ ๋๋ฆฐ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ค.
โฐ ๋งค๋ฒ 2๋ฐฐ๋ก ๋์ด๋๋ ์๊ณ ๋ฆฌ์ฆ์ด ํด๋นํ๋ฉฐ ์ฌ๊ท๋ก ๊ตฌํํ๋ ํผ๋ณด๋์น ์์ด์ด ๋ํ์ ์ด๋ค.
function fibonacci(n) {
if (n <= 1) {
return 1;
}
return fibonacci(n - 1) + fibonacci(n - 2);
}
๐ฏ. ๋ฐ์ดํฐ ํฌ๊ธฐ์ ๋ฐ๋ฅธ ์๊ฐ ๋ณต์ก๋
โฐ n ≤ 500 ์ผ๋ก ์ ๋ ฅ์ด ์ ํ๋ ๊ฒฝ์ฐ์๋ O(n³)์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ง ์ ์๋ค๊ณ ์์ธกํ ์ ์๊ณ , ๊ตณ์ด O(log n)์ผ๋ก ์ค์ผ ํ์๋ ์์ง๋ง, n ≤ 1000000์ธ ๊ฒฝ์ฐ์๋ O(n) ๋๋ O(log n)์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ง ์ ์๋๋ก ๋ฌธ์ ๋ฅผ ํ์ด์ผ ํ๋ค.
๋ฐ์ดํฐ ํฌ๊ธฐ ์ ํ | ์์ ์๊ฐ ๋ณต์ก๋ |
n ≤ 1,000,000 | O(n) or O (logn) |
n ≤ 10,000 | O(n2) |
n ≤ 500 | O(n3) |
๐ฃ ๊ณต๊ฐ ๋ณต์ก๋
๐ญ. ๊ณต๊ฐ ๋ณต์ก๋
โ๏ธ ์๊ณ ๋ฆฌ์ฆ์ด ์ํ๋๋ ๋ฐ์ ํ์ํ ๋ฉ๋ชจ๋ฆฌ์ ์ด๋์ ์๋ฏธํ๋ค.
โฐ ํ๋ก๊ทธ๋จ์ด ํ์๋ก ํ๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ฐ์ถํ๋ ๊ฒ
โฐ ๋น ์ค (Big-O) ํ๊ธฐ๋ฒ์ผ๋ก ํํํ๋ค.
๐ฎ. ๊ณต๊ฐ ๋ณต์ก๋ ์์
function factorial(n) {
if(n === 1) {
return n;
}
return n*factorial(n-1);
}
โฐ n์ ๋ฐ๋ผ ๋ณ์ n์ด n๊ฐ ๋ง๋ค์ด์ง๊ฒ ๋๋ฉฐ, factorial ํจ์๋ฅผ ์ฌ๊ทํจ์๋ก 1๊น์ง ํธ์ถํ ๊ฒฝ์ฐ n๋ถํฐ 1๊น์ง ์คํ์ ์์ด๊ฒ ๋๋ค.
โฐ ์ ํจ์์ ๊ณต๊ฐ ๋ณต์ก๋๋ O(n) ์ด๋ค.
๐ฏ. ๊ณต๊ฐ ๋ณต์ก๋์ ์ค์์ฑ
โฐ ์๊ฐ๋ณต์ก๋ ๋ณด๋ค๋ ์ค์์ฑ์ด ๋จ์ด์ง์ง๋ง, ๋์ ๊ฒํ๋ฒ ์ฒ๋ผ ์๊ณ ๋ฆฌ์ฆ์ด๋ ํ๋์จ์ด ํ๊ฒฝ์ด ๋งค์ฐ ํ์ ๋ ๊ฒฝ์ฐ ๊ณต๊ฐ ๋ณต์ก๋๊ฐ ์ค์ํด์ง๋ค.
โฐ ๋์ ๊ณํ๋ฒ์ ์๊ณ ๋ฆฌ์ฆ ์์ฒด๊ฐ ๊ตฌํ ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ง์ด ์๊ตฌํ๊ธฐ ๋๋ฌธ์ ์ ๋ ฅ๊ฐ์ ๋ฒ์๊ฐ ๋์ด์ง๋ฉด ์ฌ์ฉํ์ง ๋ชปํ๋ ๊ฒฝ์ฐ๋ ๋ง๊ณ , ํ๋์จ์ด ํ๊ฒฝ์ด ๋งค์ฐ ํ์ ๋์ด ์๋ ๊ฒฝ์ฐ, ๊ฐ์ฉ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ ํ๋์ด ์๊ธฐ ๋๋ฌธ์ด๋ค.
'CodeStates > learning contents' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
S4) Unit 11. [์๋ฃ๊ตฌ์กฐ/์๊ณ ๋ฆฌ์ฆ] Algorithm with Math & ์ ๊ทํํ์ (0) | 2023.04.06 |
---|---|
S4) Unit 11. [์๋ฃ๊ตฌ์กฐ/์๊ณ ๋ฆฌ์ฆ] Algorithm ์ ํ (0) | 2023.04.05 |
S4) Unit 10. [Deploy]Github Action & Proxy (0) | 2023.04.04 |
S4) Unit 10. [Deploy]๊ฐ๋ฐ ํ๋ก์ธ์ค (0) | 2023.04.03 |
S4) Unit 9. [Deploy]Amazon Web Service (0) | 2023.03.31 |