๋จ๋ฐฉํฅ ๊ทธ๋ํ์ ํ ๊ตฌ์กฐ๋ก, ํ๋์ ๋ฟ๋ฆฌ๋ก๋ถํฐ ๊ฐ์ง๊ฐ ์ฌ๋ฐฉ์ผ๋ก ๋ป์ ํํ๊ฐ ๋๋ฌด์ ๋ฎ์ ์๋ค๊ณ ํด์ ํธ๋ฆฌ ๊ตฌ์กฐ๋ผ๊ณ ๋ถ๋ฅธ๋ค.
๋ฐ์ดํฐ๋ฅผ ์์ฐจ์ ์ผ๋ก ๋์ด์ํจ ์ ํ ๊ตฌ์กฐ๊ฐ ์๋๋ผ, ํ๋์ ๋ฐ์ดํฐ ์๋์ ์ฌ๋ฌ ๊ฐ์ ๋ฐ์ดํฐ๊ฐ ์กด์ฌํ ์ ์๋ ๋น์ ํ ๊ตฌ์กฐ๋ก, ์๋๋ก๋ง ๋ป์ด๋๊ฐ๊ธฐ ๋๋ฌธ์ ์ฌ์ดํด์ด ์๋ค.
์ฆ, ์ฌ์ดํด์ด ์๋ ํ๋์ ์ฐ๊ฒฐ ๊ทธ๋ํ๋ผ๊ณ ํ ์ ์๋ค.
์์ ์ด๋ฏธ์ง๋ฅผ ์ฐธ๊ณ ํด ์ฉ์ด๋ฅผ ์ดํด๋ณด๋ฉด,
๋ฃจํธ(Root) : ํธ๋ฆฌ ๊ตฌ์กฐ์ ์์์ ์ด ๋๋ ๋ ธ๋
๋ถ๋ชจ ๋ ธ๋(Parent node) : ๋ ๋ ธ๋๊ฐ ์ํ๊ด๊ณ๋ก ์ฐ๊ฒฐ๋์ด ์์ ๋ ์๋์ ์ผ๋ก ๋ฃจํธ์์ ๊ฐ๊น์ด ๋ ธ๋
์์ ๋ ธ๋(Child node) : ๋ ๋ ธ๋๊ฐ ์ํ๊ด๊ณ๋ก ์ฐ๊ฒฐ๋์ด ์์ ๋ ์๋์ ์ผ๋ก ๋ฃจํธ์์ ๋จผ ๋ ธ๋
๋ฆฌํ(Leaf) : ํธ๋ฆฌ ๊ตฌ์กฐ์ ๋ ์ง์ ์ด๋ฉฐ ์์ ๋ ธ๋๊ฐ ์๋ ๋ ธ๋
๊น์ด(depth)
๋ฃจํธ~ํ์ ๊ณ์ธต์ ํน์ ๋
ธ๋๊น์ง์ ๊น์ด
ex) root = 0 / Q,R = 1 / A,B,C,D = 2 ...
๋ ๋ฒจ(level)
๊ฐ์ ๊น์ด๋ฅผ ๊ฐ์ง๊ณ ์๋ ๋
ธ๋๋ฅผ ๋ฌถ์ด์ ๋ ๋ฒจ๋ก ํํํ ์ ์์ผ๋ฉฐ, ๊ฐ์ ๋ ๋ฒจ์ ๋๋ํ ์๋ ๋
ธ๋๋ฅผ ํ์ ๋
ธ๋(Slibling Node)๋ผ๊ณ ํ๋ค.
ex) P = 1 / Q,R = 2 / A,B,C,D = 3 ...
๋์ด(Height)
๋ฆฌํ ๋
ธ๋๋ฅผ ๊ธฐ์ค์ผ๋ก ๋ฃจํธ๊น์ง์ ๋์ด๋ฅผ ํํํ ์ ์๋ค.
ex) E,F,G,B,H,I,D = 0 / L,M = 1 / A,C = 2 / Q,R = 3 / P = 4
class Tree {
constructor(value) {
// constructor๋ก ๋ง๋ ๊ฐ์ฒด๋ ํธ๋ฆฌ์ Node๊ฐ ๋๋ค.
//tree์ ์์ ๋
ธ๋๋ค์ children์ผ๋ก ํ ๋นํ์ฌ ๋
ธ๋์ ์์ ๋
ธ๋๋ค์ ๋ด์ ์ ์๊ฒ ์ค์ ํ๋ค.
this.value = value;
this.children = [];
}
// ํธ๋ฆฌ์ ์ฝ์
๋ฉ์๋.
//tree์ ์์ ๋
ธ๋๋ฅผ ์์ฑ ํ ํ์, ๋
ธ๋์ children์ push
insertNode(value) {
const childNode = new Tree(value);
this.children.push(childNode);
}
// ํธ๋ฆฌ ์์ ํด๋น ๊ฐ์ด ํฌํจ๋์ด ์๋์ง ํ์ธํ๋ ๋ฉ์๋.
// tree์์ value๊ฐ์ ํ์ -> ํ์ฌ ๋
ธ๋์ value ๊ฐ์ด ์ฐพ๋ ๊ฐ๊ณผ ์ผ์นํ๋ค๋ฉด return.
contains(value) {
if (this.value === value) {
return true;
}
// ๋
ธ๋๊ฐ ๊ฐ์ง ์์ ๋
ธ๋๋ฅผ ์ํํ๋ ๋ฐ๋ณต๋ฌธ์ผ๋ก ๋
ธ๋์ children ๋ฐฐ์ด์ ํ์
for (let i = 0; i < this.children.length; i++) {
const childNode = this.children[i];
if (childNode.contains(value)) {
return true;
}
}
// ์ ๋ถ ํ์ํ์์๋ ๋ถ๊ตฌํ๊ณ ์ฐพ์ง ๋ชปํ๋ค๋ฉด false return.
return false;
}
}
// ์
์ถ๋ ฅ
const rootNode = new Tree(null);
for(let i = 0; i <= 4; i++) {
if(rootNode.children[i]) {
rootNode.children[i].insertNode(i);
}
rootNode.insertNode(i);
}
rootNode; // {value: null, children: Array(5)}
rootNode.contains(5); // false
rootNode.contains(1); // true
์ด๋ค ํ๋ก๊ทธ๋จ์ด๋ ํ์ผ์ ์ฐพ์ ๋, ๋ฐํํ๋ฉด ํด๋ ๋๋ ๋ค์ด๋ก๋ ํด๋ ๋ฑ์์ ๋ค๋ฅธ ํด๋์ ์ง์
ํ๊ณ , ๊ทธ ์์์ ๋ ๋ค๋ฅธ ํด๋์ ์ง์
ํ๋ ์์ผ๋ก ์ฐพ๋๋ฐ, ๋ชจ๋ ํด๋๋ ๋ฃจํธ ํด๋/
์์ ์์๋์ด ๊ฐ์ง๋ฅผ ๋ป์ด๋๊ฐ๋ ํํ์ด๋ค.
Reference: ์ฝ๋์คํ ์ด์ธ