์๊ธฐ ์์ ์ ํธ์ถํ๋ ํจ์๋ฅผ ์ฌ๊ทํจ์๋ผ๊ณ ํ๋ฉฐ, ์ฌ๊ทํจ์๋ฅผ ํ์ฉํด ๋ฐ๋ณต์ ์ธ ์์ ์ ํด์ผํ๋ ๋ฌธ์ ๋ฅผ ๋์ฑ ๊ฐ๊ฒฐํ ์ฝ๋๋ก ํ์ด๋ผ ์ ์๋ค.
์ฃผ์ด์ง ๋ฌธ์ ๋ฅผ ๋น์ทํ ๊ตฌ์กฐ์ ๋ ์์ ๋ฌธ์ ๋ก ๋๋ ์ ์๋ ๊ฒฝ์ฐ, ํน์ ์ค์ฒฉ๋ ๋ฐ๋ณต๋ฌธ์ด ๋ง๊ฑฐ๋ ๋ฐ๋ณต๋ฌธ์ ์ค์ฒฉ ํ์๋ฅผ ์์ธกํ๊ธฐ ์ด๋ ค์ด ๊ฒฝ์ฐ์ ์ฌ์ฉํ๋ค. ๋ฐ๋ผ์, ๋ชจ๋ ์ฌ๊ทํจ์๋ ๋ฐ๋ณต๋ฌธ์ผ๋ก ํํํ ์ ์๋ค.
์ฌ๊ท๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ์ ์๋์ ๊ฐ๋ค.
์์ ๋ฐฉ๋ฒ์ ์ด์ฉํด arrSum
ํจ์๋ก [1, 2, 3, 4, 5]
์ ํฉ์ ๊ตฌํ๋ ๊ณผ์ ์ ์์๋ก ๋ค๋ฉด, ์๋์ ๊ฐ๋ค.
// ๋ฌธ์ ๋ฅผ ๊ฐ์ฅ ์์ ๋จ์๋ก ์ชผ๊ฐ ๋ค.
arrSum([1, 2, 3, 4, 5]) === 1 + arrSum([2, 3, 4, 5])
arrSum([2, 3, 4, 5]) === 2 + arrSum([3, 4, 5])
arrSum([3, 4, 5]) === 3 + arrSum([4, 5])
arrSum([4, 5]) === 4 + arrSum([5])
arrSum([5]) === 5 + arrSum([]) // ๊ฐ์ฅ ์์ ๋ฌธ์ = arrSum([])
์ ๋จ๊ณ๋ฅผ ๋ฐ์ํด, ํจ์๋ฅผ ์์ฑํด๋ณด๋ฉด ์๋์ ๊ฐ๋ค.
function arrSum (arr) {
// ๋น ๋ฐฐ์ด์ ๋ฐ์์ ๋ 0์ ๋ฆฌํดํ๋ ์กฐ๊ฑด๋ฌธ
// --> ๊ฐ์ฅ ์์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ์ฝ๋ & ์ฌ๊ท๋ฅผ ๋ฉ์ถ๋ ์ฝ๋
// ์กฐ๊ฑด๋ฌธ์ ์ํด ๋ ์ด์ ์๊ธฐ์์ ์ ํธ์ถํ์ง ์๊ณ , ์ซ์ 0๋ฅผ returnํ๋ฉด์ ์ข
๋ฃ.
if (arr.length === 0) {
return 0
}
// ๋ฐฐ์ด์ ์ฒซ ์์ + ๋๋จธ์ง ์์๊ฐ ๋ด๊ธด ๋ฐฐ์ด์ ๋ฐ๋ arrSum ํจ์
// --> ์ฌ๊ท(์๊ธฐ ์์ ์ ํธ์ถ)๋ฅผ ํตํด ๋ฌธ์ ๋ฅผ ์๊ฒ ์ชผ๊ฐ๋๊ฐ๋ ์ฝ๋
return arr.shift() + arrSum(arr) // 0๋ฒ์งธ ์ธ๋ฑ์ค๋ฅผ ์ญ์ ํด๊ฐ๋ฉด์ ++
}
1) ์ฌ๊ท ํจ์์ ์ ๋ ฅ๊ฐ๊ณผ ์ถ๋ ฅ๊ฐ์ ์ ์ํ๋ค.
์ด๋, ์ถ์์ ์ผ๋ก ๋๋ ๋จ์ํ๊ฒ ์ ์ํด์ผ ํ๋ค.
arrSum: [number] => number
โ ์
์ถ๋ ฅ๊ฐ ์ ์2) ๋ฌธ์ ๋ฅผ ์ชผ๊ฐ๊ณ ๊ฒฝ์ฐ์ ์๋ฅผ ๋๋๊ธฐ
๋ฌธ์ ๋ฅผ ์ชผ๊ฐค ๊ธฐ์ค์ ์ ํ๊ณ , ๊ธฐ์ค์ ๋ฐ๋ผ ๋ ํฐ ๊ฒฝ์ฐ์ ์์ ๊ฒฝ์ฐ๋ก ๊ตฌ๋ถํ ์ ์๋ ์ง ํ์ธํ๋ค. ์ผ๋ฐ์ ์ผ๋ก, ์ ๋ ฅ๊ฐ์ ๊ธฐ์ค์ผ๋ก ์ ํ๋ค.
์ด๋, ์ค์ํ ๊ด์ ์ ์ ๋ ฅ๊ฐ, ๋ฌธ์ ์ ์์, ํฌ๊ธฐ๋ก, ๋ฌธ์ ๋ฅผ ๊ตฌ๋ถํ๋ ๋ฐ ์์ํ๋ค.
ํจ์ arrSum
์ ๊ฒฝ์ฐ ์
๋ ฅ๊ฐ์ธ ๋ฐฐ์ด์ ํฌ๊ธฐ์ ๋ฐ๋ผ, ๋ ์์ ๋ฌธ์ ๋ก ๋๋ ์ ์๋ค.
arrSum([1, 2, 3, 4])
๋ฅผ ๊ตฌํ๋ ๋ฐฉ๋ฒ๊ณผ arrSum([2, 3, 4])
์ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ ๋์ผํ๋ค.
ํจ์ arrSum
์ ์
๋ ฅ๊ฐ์ด ๋น ๋ฐฐ์ด์ธ ๊ฒฝ์ฐ์ ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ๋ก ๋๋ ์ ์์ผ๋ฉฐ, ๊ฐ๊ฐ ๋ค๋ฅธ ๋ฐฉ์์ผ๋ก ์ฒ๋ฆฌํด์ผ ํ๋ค.
arrSum: [number] => number
arrSum([ ]) โ ์
๋ ฅ๊ฐ์ด ๋น ๋ฐฐ์ด์ธ ๊ฒฝ์ฐ
arrSum([์์1, ์์2, ... , ์์n]) โ ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ
3) ๋จ์ํ ๋ฌธ์ ํด๊ฒฐํ๊ธฐ
๋ฌธ์ ๋ฅผ ์ฌ๋ฌ ๊ฒฝ์ฐ๋ก ๊ตฌ๋ถํ ๋ค์, ๊ฐ์ฅ ํด๊ฒฐํ๊ธฐ ์ฌ์ด ๋ฌธ์ ๋ถํฐ ํด๊ฒฐํ๋ฉฐ ์ด๋ฅผ ์ฌ๊ท์ ๊ธฐ์ด(base case)๋ผ๊ณ ํ๋ค.
์ฌ๊ท์ ๊ธฐ์ด๋ ์ฌ๊ท ํจ์๋ฅผ ๊ตฌํํ ๋, ์ฌ๊ท์ ํ์ถ ์กฐ๊ฑด(์ฌ๊ท ํธ์ถ์ด ๋ฉ์ถ๋ ์กฐ๊ฑด)์ ๊ตฌ์ฑํ๋ค.
๋ฐ๋ผ์, ๋ฌธ์ ๋ฅผ ์ต๋ํ ์๊ฒ ์ชผ๊ฐ ํ์ ํด๊ฒฐํ๋ ๊ฒ์ด ์ค์ํ๋ค.
arrSum: [number] => number
arrSum([ ]) โ ์
๋ ฅ๊ฐ์ด ๋น ๋ฐฐ์ด์ธ ๊ฒฝ์ฐ : ํด๊ฒฐ!
arrSum([์์1, ์์2, ... , ์์n]) โ ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ
4) ๋ณต์กํ ๋ฌธ์ ํด๊ฒฐํ๊ธฐ
arrSum
์ ์
๋ ฅ๋ ๊ฒฝ์ฐ, ์
๋ ฅ๋ ๋ฐฐ์ด์ ๋ฐฐ์ด์ ์ฒซ ์์์ ๋๋จธ์ง ์์๋ฅผ ์
๋ ฅ๊ฐ์ผ๋ก ๊ฐ๋ ๋ฌธ์ ๋ก ์ชผ๊ฐ๊ณ , ๋์ ๋ํ๋ค.arrSum: [number] => number
arrSum([ ]) === 0
arrSum([์์1, ์์2, ... , ์์n]) === ์์1 + arrSum([์์2, ..., ์์n]) โ ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ : ํด๊ฒฐ!
์๋๋ ์ผ๋ฐ์ ์ธ ์ฌ๊ท ํจ์์ ํ ํ๋ฆฟ์ด๋ค.
function recursive(input1, input2, ...) {
// base case : ๋ฌธ์ ๋ฅผ ๋ ์ด์ ์ชผ๊ฐค ์ ์๋ ๊ฒฝ์ฐ
if (๋ฌธ์ ๋ฅผ ๋ ์ด์ ์ชผ๊ฐค ์ ์์ ๊ฒฝ์ฐ) {
return ๋จ์ํ ๋ฌธ์ ์ ํด๋ต;
}
// recursive case : ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ
return ๋ ์์ ๋ฌธ์ ๋ก ์๋กญ๊ฒ ์ ์๋ ๋ฌธ์
}
์๋๋ ์์ ํ ํ๋ฆฟ์ ์ ์ฉํด ํฉํ ๋ฆฌ์ผ์ ๊ตฌํํ ์์ ์ด๋ค.
function factorial(n){
if(n === 1){
return 1;
}
return n * factorical(n-1);
}
Reference: ์ฝ๋์คํ ์ด์ธ