๋ฌธ์ ํ์ด๋ ์ ๋ถ ํ ์ ์๋ ๋ฌธ์ ๋ค์ด๋ผ์ ์๋ก ์ ์ค๋ช ํ์ค ๋ ํ์ด์ฌ์ผ๋ก ํ๋ฑ ํ๊ณ ์ค๋ช ๋ค์ผ๋ฉด์ ์๋ฐ์คํฌ๋ฆฝํธ ์ฐธ๊ณ ํ ์ ์ด๋, ๋ด ๋ก์ง์์ ์์ ํ ์ ์ ์ฒดํฌํ๋ค.
์ ์ ์ ๊ทํํ์ ์ฒ์ ๋์ฌ ๋ ์ธ๊ธํ์ ๋ฌธ์ ๋ผ์ ์ ๊ท์์ผ๋ก ๋ฐ๋ก ์ ๊ทผํ ์ ์์๋ค. ์ ๊ท์์ ์ฌ์ค ์ฐ๋ ค๊ณ ํ๋ฉด ๋ช ๊ฐ ๋นผ๊ณ ๋ ๋ค ๊ธฐ์ต์ด ๋๋๋ฐ.. ์ ๊ท์ ๋ชจ๋ ํจ์๋ค์ด ๊ธฐ์ต์ด ์๋๋ค. ํ์ด์ฌ re ๋ฌธ์, apple regex ๋ฌธ์ ์ ๋ ํ์
๋คํธ ๊ฒ์์ ๊ณต๊ต๋กญ๊ฒ๋.. ์ ๋ฒ์ฃผ ์คํฐ๋ ๋ฌธ์ ์๋๋ฐ ์ ๋ฒ ์ฃผ์ ๋๋ฌด ๋ฐ๋น ์ ๋ชปํ๋ค๊ฐ ์ด์ ํผ!! ๋ฌธ์ ์๋ค. ์ ์๋์ ํ์ด๊ฐ ๋ด ํ์ด๋์ ์กฐ๊ธ ์ฐจ์ด๊ฐ ์์์ง๋ง, ๊ธฐ๋ณธ ๋ก์ง์ ๊ฐ์๋ค.
์บ์๋ LRU๋ฅผ ์ด์ฉํ๋ ๋ฌธ์ ์๋๋ฐ, ์บ์ ์ฌ์ด์ฆ๊ฐ 0์ธ ํ ์คํธ ์ผ์ด์ค ํ๋ ๋นผ๋จน๊ณ .. ๋ฌธ์ ๋ฅผ ๋๋ฌด ์ธ๋ถํํด์ ํ์๋ค๊ฐ ์ค๋ณต๋๋ ์ฝ๋๊ฐ ๋ง์์ ๊นจ๋ซ๊ณ ๋ง์ง๋ง์ ์์ถํ๋ค.
class Node {
constructor(data){
this.data = data;
// this.child = []; // 2์งํธ๋ฆฌ๊ฐ ์๋ ํธ๋ฆฌ๊ฐ ๋จ
this.left = null;
this.right = null;
}
}
class Tree {
constructor(data) {
let init = new Node(data);
this.root = init;
this.๋ฐ์ดํฐ์ = 0;
}
length(){
return this.๋ฐ์ดํฐ์;
}
insert(data){
let ์๋ก์ด๋
ธ๋ = new Node(data);
let ์ํ์ฉํ์ฌ๋
ธ๋ = this.root;
while(์ํ์ฉํ์ฌ๋
ธ๋){
if (data === ์ํ์ฉํ์ฌ๋
ธ๋.data){
// ์ค๋ณต๋ ๊ฐ์ ํ๋ฝ!
return;
}
if (data < ์ํ์ฉํ์ฌ๋
ธ๋.data){
// ๋ค์ด์จ ๋ฐ์ดํฐ๊ฐ ์์ผ๋ฉด ์ผ์ชฝ
// ๋น์ด์์ผ๋ฉด ๋ฐ์ดํฐ๋ฅผ ๋ฃ๊ณ , ๋น์ด์์ง ์์ผ๋ฉด ํ๊ณ ๋ ๋ด๋ ค๊ฐ์ผํฉ๋๋ค.
if (!์ํ์ฉํ์ฌ๋
ธ๋.left){
์ํ์ฉํ์ฌ๋
ธ๋.left = ์๋ก์ด๋
ธ๋;
return;
}
์ํ์ฉํ์ฌ๋
ธ๋ = ์ํ์ฉํ์ฌ๋
ธ๋.left;
}
if (data > ์ํ์ฉํ์ฌ๋
ธ๋.data){
if (!์ํ์ฉํ์ฌ๋
ธ๋.right){
์ํ์ฉํ์ฌ๋
ธ๋.right = ์๋ก์ด๋
ธ๋;
return;
}
์ํ์ฉํ์ฌ๋
ธ๋ = ์ํ์ฉํ์ฌ๋
ธ๋.right;
}
}
this.๋ฐ์ดํฐ์ += 1;
}
DFS(){
// ๊น์ด์ฐ์ ํ์, DFS(Depth First Search)
// Stack ์ด์ฉ!
let ๊ฒฐ๊ณผ๊ฐ = [];
let ์คํ = [this.root];
while(์คํ.length !== 0){
let current = ์คํ.pop();
if (current.right) {
์คํ.push(current.right);
}
if (current.left) {
์คํ.push(current.left);
}
๊ฒฐ๊ณผ๊ฐ.push(current.data);
}
return ๊ฒฐ๊ณผ๊ฐ;
}
BFS(){
// BFS๋ DFS์ ์คํ์ ํ๋ก๋ง ๋ฐ๊พธ์ด์ฃผ๋ฉด ๋๋ค.
// .pop() ๋์ .shift()
}
}
+ ๋ ๋ ๋ธ๋ ํธ๋ฆฌ : ๋ถ๊ท ํํ ์ด์งํธ๋ฆฌ๊ฐ ์๊ฒจ์ ํ์ ํจ์จ์ด ์์ข์์ง๋ ๊ฒฝ์ฐ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํ ํธ๋ฆฌ.