์ด์ง ๊ฒ์ ํธ๋ฆฌ Binary Search Tree
์ ๋ฒ ์๊ฐ์๋ ํ์์ ๋ํด์ ์ดํด๋ดค๋๋ฐ, ํน์ ์๋ฃ๊ฐ ์กด์ฌํ๋์ง ์ฐพ์๋ณด๊ธฐ ์ํด ๋งค ๋ฒ ํธ๋ฆฌ๋ฅผ ํ์ํ๋๊ฑด ๋งค์ฐ ๋นํจ์จ์ ์ธ ๋ฐฉ๋ฒ์ด๋ค.
๊ทธ๋์ ๋ง๋ ์ด์งํธ๋ฆฌ์ ๋ณํ์ด ๋ฐ๋ก ์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ค.
ํต์ฌ์ ๊ฐ ๋
ธ๋์ ๋ค์ด๊ฐ ์ ์๋ ๊ฐ์ ์ ํํ๋ ๊ฒ์ด๋ค.
๊ฐ๋ น ๋ถ๋ชจ ๋
ธ๋์ ๊ฐ์ ๋น๊ตํด์ ์์ผ๋ฉด ์ผ์ชฝ, ํฌ๋ฉด ์ค๋ฅธ์ชฝ ๋
ธ๋๋ก ๊ฐ๊ฒ ํ๋ค๋๊ฐ ํ๋ ๋ฑ์ ์ ํ์ ๋๋๊ฒ.
๊ฒ์ ์ฐ์ฐ
(์์ฐ์ ๋น๊ต์ ๊ฒฝ์ฐ)
- ๋ฃจํธ ๋ ธ๋์์ ์์ํด์ ์ฐพ๋ ๋ฐ์ดํฐ๊ฐ ๋ ธ๋์ ๋ฐ์ดํฐ๋ณด๋ค ์์ผ๋ฉด ์ผ์ชฝ ๋ ธ๋๋ก, ํฌ๋ฉด ์ค๋ฅธ์ชฝ ๋ ธ๋๋ก ์ด๋.
- ์ฐพ๋ ๋ฐ์ดํฐ๊ฐ ๋ ธ๋์ ๋ฐ์ดํฐ์ ๊ฐ์ผ๋ฉด ํ์ฌ ๋ ธ๋๋ฅผ ๋ฆฌํด
- ์ฐพ๋ ๋ฐ์ดํฐ๋ฅผ ๋ฆฌํ๋
ธ๋์ ๋์ฐฉํ ๋ ๊น์ง ์ฐพ์ง ๋ชปํ๋ฉด Null์ ๋ฐํ(๋ฆฌํ๋
ธ๋์ ๋ชจ๋ ํฌ์ธํฐ๋ ๋ค null์ด๊ธฐ ๋๋ฌธ์)
์ฌ๊ท vs while ๋ฐ๋ณต
์ฌ๊ท์ ๋ํ ์์
๋ ์ค๋ช
ํ ๋ด์ฉ์ด์ง๋ง, ์ฌ๊ทํธ์ถ์ ์ผ๋ฐ์ ์ผ๋ก ์คํ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ ๋ง์ด ์ฌ์ฉํ๋ฏ๋ก ๊ณต๊ฐ ๋ณต์ก๋๋ฅผ ๋ ๋ง์ด ํ์๋ก ํ๋ค. ( ๊ณผ )
๊ทธ๋์ ์์ ๊ฒ์ ์์์์๋ ๋ค์๊ณผ ๊ฐ์ด while ๋ฐ๋ณต์ ์ฌ์ฉํ๋ฉด ๊ฐ์ ์ผ์ ํจ์ฌ ํจ์จ์ ์ผ๋ก ์ํํ ์ ์๋ค.
Node* search(Node* root, int target) {
Node* current = root;
while (current != NULL) {
if (target < current->data) {
current = current->left;
}
else if (target > current->data) {
current = current->right;
}
else {
return current;
}
}
return NULL;
}
์ ์ ํ์ ๋ ธ๋
์ค์ ์ ์ ๋
ธ๋, ํ์ ๋
ธ๋ :
๋ชจ๋ ๋
ธ๋๋ค์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ์ ๋, ํด๋น ๋
ธ๋์ ์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ์ ์์นํ ๋
ธ๋๋ค์ ๋งํ๋ค.
ํธ๋ฆฌ ๊ตฌ์กฐ์์์ ์๊ธฐ ์ผ์ชฝ, ์ค๋ฅธ์ชฝ์ด ์๋๋ผ.
์ฝ์
๊ฒ์ ์ฐ์ฐ๊ณผ ๋งค์ฐ ๋น์ทํ๋ค.
ํธ๋ฆฌ์ 5๋ฅผ ๋ฃ๊ณ ์ถ๋ค๋ฉด 5๋ฅผ ๋ฃ์ ์์น๋ก ์ฐพ์๊ฐ์ 5๊ฐ ์๋ค๋ฉด ๊ทธ ์๋ฆฌ์ ์ฝ์
ํ๋ฉด ๋.
๊ทธ๋ฐ๋ฐ ์ฃผ์ํ ์ ์, ์๋ก์ด ๋
ธ๋๋ฅผ ์ฝ์
ํ๋ฉด ๋ถ๋ชจ ๋
ธ๋์๊ฒ ์๋ก์ด ๋
ธ๋ ์ฃผ์๊ฐ์ ์ ๋ฌํด์ค์ผ ํ๋ค๋ ์ ์ด๋ค.