๐ก ์ด๋ฒ์๋ ์ด์ง ํธ๋ฆฌ๋ก ๊ตฌํ ๋ฐ ์ํ ํ๋ ๋ฒ์ ๋ฐฐ์๋ณด์๋ค.
๋ฌธ์
๐ก ์ด์ง ํธ๋ฆฌ๋ก ๊ตฌํ ๋ฐ ์ํํ ์ ์๊ฒ ๊ตฌํํ์์ค.
๋น์ฐํ ์๋ ๋ฌธ์ ๊ธฐ์ ๋์ถฉ ๋ด๊ฐ ๋ง๋ค์๋ค.
ํด๋ต
#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
int data;
struct Node *leftChild;
struct Node *rightChild;
} Node;
Node* initNode(int data, Node* leftChild, Node* rightChild) {
Node* node = (Node*)malloc(sizeof(Node));
node->data = data;
node->leftChild = leftChild;
node->rightChild = rightChild;
return node;
}
void preorder(Node* root) {
if (root) {
printf("%d ", root->data);
preorder(root->leftChild);
preorder(root->rightChild);
}
}
void inorder(Node* root) {
if (root) {
inorder(root->leftChild);
printf("%d ", root->data);
inorder(root->rightChild);
}
}
void postorder(Node* root) {
if (root) {
postorder(root->leftChild);
postorder(root->rightChild);
printf("%d ", root->data);
}
}
int main(void) {
Node* n7 = initNode(50, NULL, NULL);
Node* n6 = initNode(37, NULL, NULL);
Node* n5 = initNode(23, NULL, NULL);
Node* n4 = initNode(5, NULL, NULL);
Node* n3 = initNode(48, n6, n7);
Node* n2 = initNode(17, n4, n5);
Node* n1 = initNode(30, n2, n3);
preorder(n1);
printf("\\n");
inorder(n1);
printf("\\n");
postorder(n1);
return 0;
}
์ค๋ช
ํธ๋ฆฌ๋?
- ํธ๋ฆฌ(Tree)๋ ๋๋ฌด์ ํํ๋ฅผ ๋ค์ง์ ๊ฒ๊ณผ ๊ฐ์ ํํ์ ์๋ฃ ๊ตฌ์กฐ์ด๋ค.
- ๋งจ ์์ ๋ฃจํธ ๋
ธ๋๊ฐ ์์ผ๋ฉฐ, ๊ฐ์ง๋ก ์ด์ด์ง ์์ ๋
ธ๋, ๋ ๋
ธ๋๋ฅผ ๋ฆฌํ ๋
ธ๋๋ผ๊ณ ํ๋ค.
- ๊ฐ์ ๋ถ๋ชจ๋ฅผ ๊ฐ์ง ๊ฐ์ ๊น์ด์ ๋ ธ๋๋ฅผ ํ์ ๋ ธ๋๋ผ๊ณ ํ๋ค.
- ๊ธธ์ด(Length)๋ ์ถ๋ฐ ๋ ธ๋์์ ๋ชฉ์ ์ง ๋ ธ๋๊น์ง ๊ฑฐ์ณ์ผ ํ๋ ๊ฐ์ง์๋ฅผ ์๋ฏธํ๋ค.
- ๊น์ด(Depth)๋ ๋ฃจํธ ๋ ธ๋์์ ํน์ ๋ ธ๋๊น์ง์ ๊ธธ์ด๋ฅผ ์๋ฏธํ๋ค.
- ๋์ด(Height)๋ ๋ฃจํธ ๋ ธ๋์์ ๊ฐ์ฅ ๊น์ ๋ ธ๋๊น์ง์ ๊ธธ์ด๋ฅผ ์๋ฏธํ๋ค.
์ด์งํธ๋ฆฌ๋?
- Binary Tree ๋ผ๊ณ ํ๋ฉฐ ์ต๋ 2๊ฐ์ ์์์ ๊ฐ์ง ์ ์๋ ํธ๋ฆฌ์ด๋ค.
- ํฌํ ์ด์ง ํธ๋ฆฌ(Full Binary Tree)๋ ๋ฆฌํ ๋ ธ๋๋ฅผ ์ ์ธํ ๋ชจ๋ ๋ ธ๋๊ฐ ๋ ์์์ ๊ฐ์ง๊ณ ์๋ ํธ๋ฆฌ์ด๋ค.
- ์์ ์ด์ง ํธ๋ฆฌ(Complete Binary Tree)๋ ๋ชจ๋ ๋ ธ๋๋ค์ด ์ผ์ชฝ ์์๋ถํฐ ์ฐจ๊ทผ์ฐจ๊ทผ ์ฑ์์ง ํธ๋ฆฌ์ด๋ค.
- ๋์ด ๊ท ํ ํธ๋ฆฌ(Height Balanced Tree)๋ ์ผ์ชฝ ์์ ํธ๋ฆฌ์ ์ค๋ฅธ์ชฝ ์์ ํธ๋ฆฌ์ ๋์ด๊ฐ 1 ์ด์ ์ฐจ์ด๋์ง ์๋ ํธ๋ฆฌ์ด๋ค.
- ์ด์ง ํธ๋ฆฌ๋ ๋ง์ ์์ ๋ ธ๋๋ฅผ ๋ฎ์ ๋์ด์์ ๊ด๋ฆฌํ ์ ์๋ค๋ ์ ์์ ๋ฐ์ดํฐ ํ์ฉ์ ํจ์จ์ฑ์ด ๋์์ง๋ค.
- ๋ฐ์ดํฐ ์ ์ฅ, ํ์ ๋ฑ์ ๋ค์ํ ๋ชฉ์ ์์ ์ฌ์ฉํ ์ ์๋ค.
Node์ Treeํํ๋ก ์ด๊ธฐํ
#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
int data; // ์ค์ ๋ก๋ ์ ์ํ ๋ฐ์ดํฐ๋ง ๋ค์ด๊ฐ๋ ๊ฒ์ด ์๋๋ผ ๋ง์ ๋ฐ์ดํฐ๊ฐ ๋ค์ด๊ฐ๋ค.
struct Node *leftChild;
struct Node *rightChild;
} Node;
Node* initNode(int data, Node* leftChild, Node* rightChild) {
Node* node = (Node*)malloc(sizeof(Node));
node->data = data;
node->leftChild = leftChild; // ์ผ์ชฝ ์์ ๋
ธ๋ ์ด๊ธฐํ
node->rightChild = rightChild; // ์ค๋ฅธ์ชฝ ์์ ๋
ธ๋ ์ด๊ธฐํ
return node;
}
- ์ํ ํจ์๋ค์ ๋ชจ๋ ์๋์ ์ด์งํธ๋ฆฌ๋ฅผ ์ํํ๊ณ ์๋ค๊ณ ๊ฐ์ ํ๋ค.
preorder ํจ์
void preorder(Node* root) {
if (root) {
printf("%d ", root->data);
preorder(root->leftChild);
preorder(root->rightChild);
}
}
์ ์ ์ํํจ์์ด๋ค.
root๊ฐ NULL๊ฐ์ด ์๋ ๋ ์๊ธฐ ์์ ์ ๋จผ์ ์ถ๋ ฅํ๊ณ ์ฌ๊ท์ ์ผ๋ก leftChild๋ฅผ ์ถ๋ ฅํ๊ณ ๋ค์์ผ๋ก rightChild๋ฅผ ์ถ๋ ฅํ๋ค.
์ถ๋ ฅ ๊ฒฐ๊ณผ๋ 30 17 5 23 48 37 50 ์ด๋ค.
์ฌ๊ธฐ์ ๋ด๊ฐ ํท๊ฐ๋ฆฐ ๋ถ๋ถ์ 48์ ์ถ๋ ฅํ ๋์ธ๋ฐ ๋ด๊ฐ ์๊ฐํ๊ธฐ์๋ 30 17 5 23 ๊น์ง๋ง ์ถ๋ ฅ๋๋ ๊ฒ์ผ๋ก ์์ํ์์๋ค.
์ด๋ก ์์ผ๋ก๋ ์ดํด๋ฅผ ํ์ผ๋ ์ฝ๋ ์์์ ์ถ๋ ฅ ๊ฒฐ๊ณผ๊ฐ ์ ์ ๋ ๊ฒ ๋์ค๋์ง๋ ์ค๋ช ์ ํด์ฃผ์์ง ์์์ ์ข ๋ ์ฐพ์๋ด์ผ๊ฒ ๋ค.
ํธ๋ฆฌ๋ฅผ ์ถ๋ ฅ ํ์ ๋ ธ๋ ํ ๋น ํด์ ๊ฐ ๋๋ค๋ฉด ๋ง์ด ๋ ๊ฒ ๊ฐ๋ค.
inorder ํจ์
void inorder(Node* root) {
if (root) {
inorder(root->leftChild);
printf("%d ", root->data);
inorder(root->rightChild);
}
}
์ค์ ์ํ ํจ์์ด๋ค.
์ ์ ์ํ ํจ์์ฒ๋ผ ๋ฐฑํ๋ก ์ดํด๋ ํ์ง ๋ชปํ์๋ค.
์ถ๋ ฅ ๊ฒฐ๊ณผ๋ 5 17 23 30 37 48 50 ์ด๋ค.
postorder ํจ์
void postorder(Node* root) {
if (root) {
postorder(root->leftChild);
postorder(root->rightChild);
printf("%d ", root->data);
}
}
ํ์ ์ํ ํจ์์ด๋ค.
์์ ์ด์ ๋ก ๋์ผํ๊ฒ ๋ฐฑํ๋ก ์ดํดํ์ง๋ ๋ชปํ์๋ค.
์ถ๋ ฅ ๊ฒฐ๊ณผ๋ 5 23 17 37 50 48 30 ์ด๋ค.
main ํจ์
int main(void) {
Node* n7 = initNode(50, NULL, NULL); // ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์์ ๋
ธ๋
Node* n6 = initNode(37, NULL, NULL);
Node* n5 = initNode(23, NULL, NULL);
Node* n4 = initNode(5, NULL, NULL); // ๊ฐ์ฅ ์ผ์ชฝ ์์ ๋
ธ๋
Node* n3 = initNode(48, n6, n7); // ์์๋
ธ๋ ์กด์ฌ
Node* n2 = initNode(17, n4, n5);
Node* n1 = initNode(30, n2, n3); // root node
preorder(n1); // n1์ด ๋ฃจํธ์ด๋ฏ๋ก ์ํ๋ฌผ์ ์ถ๋ ฅํ๊ธฐ์ํด n1์ ๋ฃ์ด์ค๋ค.
printf("\\n");
inorder(n1);
printf("\\n");
postorder(n1);
return 0;
}
n7~n4 ๊น์ง๋ ๋ฆฌํ๋ ธ๋์ด๊ธฐ ๋๋ฌธ์ ์์์ด ์์ด์ NULL ๊ฐ์ ๋ฃ์ด์ค๋ค.
n3~n1 ๊น์ง๋ ์์๋ ธ๋๊ฐ ์กด์ฌํ๊ธฐ ๋๋ฌธ์ ํด๋น ์์์ ๋ ธ๋๋ฅผ ๋ฃ์ด์ค๋ค.
๋ง์น๋ฉฐ..
์ด์งํธ๋ฆฌ๋ฅผ ์ํํ๋ ๊ฒ์ด ์ดํด๊ฐ ์ ๋์ง ์๋๋ค.
๋ํ ์ด์งํธ๋ฆฌ๋ฅผ ์์ฑํ ๋ ๋ฌด์กฐ๊ฑด ์ค๋ฅธ์ชฝ๋ถํฐ ์์ฑ๋๋ ๊ฒ์ธ์ง๋ ์ฐพ์๋ด์ผ ํ ๊ฒ ๊ฐ๋ค.
์ด๋ง ํฌ์คํ ์ ์ฌ๊ธฐ์ ๋ง์น์ง๋ง ํ์ ์ฐพ์์ ๋ค์ ํฌ์คํ ํ๊ฒ ๋ค.