BFS๋ ๋๋น์ฐ์ ํ์ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
์ฃผ๋ก Queue์ while๋ฌธ๊ณผ ํจ๊ป ์ฌ์ฉํ๋ค.
์ฅ์ :
1. ๋๋น๋ฅผ ์ฐ์ ์ผ๋ก ํ์ํ๊ธฐ ๋๋ฌธ์ ๋ต์ด ๋๋ ๊ฒฝ๋ก๊ฐ ์ฌ๋ฌ ๊ฐ์ธ ๊ฒฝ์ฐ์๋ ์ต๋จ ๊ฒฝ๋ก์์ ๋ณด์ฅํ๋ค.
2. ์ต๋จ ๊ฒฝ๋ก๊ฐ ์กด์ฌํ๋ค๋ฉด, ์ด๋ ํ ๊ฒฝ๋ก๊ฐ ๋ฌดํํ ๊น์ด์ง๋ค ํด๋ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ๋ฐ๋์ ์ฐพ์ ์ ์๋ค.
3. ๋
ธ๋ ์๊ฐ ์ ๊ณ ๊น์ด๊ฐ ์์ ํด๊ฐ ์กด์ฌ ํ ๋ ์ ๋ฆฌํ๋ค.
๋จ์ :
1. ํ๋ฅผ ์ด์ฉํด ๋ค์์ ํ์ ํ ๋
ธ๋๋ค์ ์ ์ฅํ๊ธฐ ๋๋ฌธ์ ๋
ธ๋์ ์๊ฐ ๋ง์ ์๋ก ํ์์๋ ๋
ธ๋๋ค๊น์ง ์ ์ฅํด์ผ ํ๊ธฐ ๋๋ฌธ์ ๋ ํฐ ์ ์ฅ๊ณต๊ฐ์ด ํ์ํ๋ค.
2.๋
ธ๋์ ์๊ฐ ๋์ด๋๋ฉด ํ์ํด์ผํ๋ ๋
ธ๋๊ฐ ๋ง์์ง๊ธฐ ๋๋ฌธ์ ๋นํจ์จ์ ์ด๋ค.
DFS๋ ๊น์ด์ฐ์ ํ์ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
์ฃผ๋ก Stack๊ณผ ์ฌ๊ทํธ์ถ์ ์ฌ์ฉํ๋ค.
์ฅ์ :
1. BFS์ ๋นํด ์ ์ฅ๊ณต๊ฐ์ ํ์์ฑ์ด ์ ๋ค. ๋ฐฑํธ๋ํน์ ํด์ผํ๋ ๋
ธ๋๋ค๋ง ์ ์ฅํด์ฃผ๋ฉด ๋๋ค.
2. ์ฐพ์์ผํ๋ ๋
ธ๋๊ฐ ๊น์ ๋จ๊ณ์ ์์ ์๋ก, ๊ทธ ๋
ธ๋๊ฐ ์ผ์ชฝ์ ์์ ์๋ก BFS๋ณด๋ค ์ ๋ฆฌํ๋ค.
๋จ์ :
1. ๋ต์ด ์๋ ๊ฒฝ๋ก๊ฐ ๋งค์ฐ ๊น๋ค๋ฉด, ๊ทธ ๊ฒฝ๋ก์ ๊น์ด ๋น ์ง ์ฐ๋ ค๊ฐ ์๋ค.
2. ์ฐพ์ ํด๊ฐ ์ต๋จ ๊ฒฝ๋ก๋ผ๋ ๋ณด์ฅ์ด ์๋ค.
๐โโ๏ธArray.prototype์๋ Stack, Queue ์ฌ์ฉ์ ์ํด ์ด๋ค ๋ฉ์๋๊ฐ ์กด์ฌํ๋์?
Stack : Array.prototype.push()
,Array.prototype.pop()
Queue :Array.prototype.push()
, Array.prototype.shift()
๊ท ํ ์ด์ง ํ์ ํธ๋ฆฌ๋ ๋ฌด์์ผ๊น์?
AVL Tree ๊ธฐ์กด ์ด์งํ์ํธ๋ฆฌ์์ ์น์ฐ์ณ์ง์ ๋ฐฉ์งํด ๊ท ํ์ ๋ง๊ฒํ๋ ์ผ์ข
์ ํธ๋ฆญ์ ๋ฃ์ ๊ตฌ์กฐ์ด๋ค.
์ด์ง ํ์ ํธ๋ฆฌ์ ๊ท ํํ ๋ฒ์ ์ด๋ค.
BF(Balance Factor)๋ฅผ ์ ์ ๊ฐ ์ค์ ํด๋์ด ํธ๋ฆฌ๋ด ์๋ธํธ๋ฆฌ๊ฐ์ ๋์ด ์ฐจ์ด๊ฐ BF๋ฅผ ์๋๊ฒ ์์๋ก ์กฐ์ ํ๋ค.
์ฝ์
์ ๊ฒฝ์ฐ 4๊ฐ์ง ์ผ์ด์ค(LL, RR, LR, RL) ๋ก ๋๋์ด, 'ํ์ ' ์ด๋ผ๋ ๊ฐ๋
์ผ๋ก ํธ๋ฆฌ ๊ท ํ์ ์ ์งํ๋ค.
(1)
/ \
(2) (3)
/ \
(4) (5)
๊ฒฐ๊ณผ : 4 2 5 1 3
๊ฒฐ๊ณผ : 1 2 4 5 3
๊ฒฐ๊ณผ : 4 5 2 3 1
์๋ฐ์คํฌ๋ฆฝํธ์๋ ๋ณ๋์ swap๋ฉ์๋๊ฐ ์๊ธฐ ๋๋ฌธ์ ์ง์ ์ฌ์ฉํด์ผํ๋ค.
const arr = [1,2,3,4,5]
let temp = arr[1]
arr[1] = arr[2]
arr[2] = temp
console.log(arr) //[1,3,2,4,5]
const arr = [1,2,3,4,5]
[arr[1], arr[2], arr[4]] = [arr[2],arr[4],arr[1]]
console.log(arr) //[1,3,5,4,2]
์ด์ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ฒ์ ๋ดค์๋๋ณด๋ค๋ ์กฐ๊ธ ์ดํดํ๊ธฐ๊ฐ ์์ํด์ก๋ค. ๊ณ์ํด์ ๋ฐ๋ณตํ๋ฉด ์ ์ดํดํ๊ฒ ์ง ใ ์ฃผ๋ง๋์ ๊ณ์ ๋ณต์ตํ๋ฉด ์ค๋๋ณด๋ค ๋ ์ดํด๋ฅผ ์ ํ๊ฒ๋ ๊ฒ๊ฐ๋ค. ์๋๋ฉด ๋ ๋๊น์ง ๋ฐ๋ณตํ์!