CH 5 Tree Contents 1 Tree 2 Binary

CH 5 Tree

Contents 1 트리(Tree)의 개념 2 이진트리(Binary Tree) 3 이진검색트리(Binary Search Tree) 4 AVL 트리 5 B 트리

이진트리(Binary Tree)

이진트리(Binary Tree)

이진트리(Binary Tree)

이진트리(Binary Tree) v 이중 연결 리스트와 유사한 방식의 노드 구조 struct bin_node { char data; struct bin_node *l_child; struct bin_node *r_child; };

이진트리(Binary Tree)

이진트리(Binary Tree) void main() { struct bin_node *root; . . . preorder(root); } void preorder (struct bin_node *tree) { if(tree == null) return; else { printf("%c ", tree->data); //루트 노드 방문 preorder(tree->l_child); //왼쪽 부트리로 preorder(tree->r_child); //오른쪽부트리로 } }

이진트리(Binary Tree) preoder() if() else printf(); preorder();

이진트리(Binary Tree) void main() 100 200 A ^ 100 root preorder(root); 200 300 B ^ void preorder (struct bin_node *tree) 100 300 ^ C ^ tree

이진트리(Binary Tree)

이진트리(Binary Tree) void inorder (struct bin_node *tree) { if(tree == null) return; else { inorder(tree->l_child); //왼쪽 부트리로 printf("%c ", tree->data); //루트 노드 방문 inorder(tree->r_child); //오른쪽 부트리로 } } 중위순회 결과: B, E, K, A, C, G ( )A( ) ((∧)B( ))A(( )C( )) ((∧)B((∧)E( )))A(( ∧ )C(( )G( ))) ((∧)B((∧)E((∧)K(∧))))A ((∧)C((∧)G(∧)))

이진트리(Binary Tree) void postorder (struct bin_node *tree) { if(tree == null) return; else { postorder(tree->l_child); //왼쪽 부트리로 postorder(tree->r_child); //오른쪽 부트리로 printf("%c ", tree->data); //루트 노드 방문 } } 후위순회 결과: K, E, B, G, C, A ( )A ((∧)( )B)((∧)( )C)A ((∧)( )E)B)((∧)(∧)G)C)A ((∧)((∧)(∧)K)E)B)((∧)(∧)G)C)A

이진검색트리(Binary Search Tree)

이진검색트리(Binary Search Tree) v Binary Search Tree의 구현 (Simple version) #include "stdio. h" #include "string. h" struct list { struct list *left; int data; struct list *right; }; 30 400 200

이진검색트리(Binary Search Tree) void main() { struct list *root, *insert(), *srch(), *modi(), *delet(), *temp; int key, data, sdata; void prnt(), inp(); FILE *fp; root= NULL; do{ printf("n Input(file)-1 Input(keyboard)-2 Display-3 Search-4 Update-5 Delete-6 End-7 n"); printf("n Select a key --->"); scanf("%d", &key);

이진검색트리(Binary Search Tree) if(key == 1) { printf("n---input---n"); fp= fopen("binary. dat", "r"); if(fp != NULL) while(fscanf(fp, "%d", &data) != EOF) { printf(“data=%dn", data); root= insert(root, data); } else printf("fopen errorn"); }

이진검색트리(Binary Search Tree) if(key == 2) { // 키보드에서 삽입할 데이터값을 입력받음 scanf("%d", &data); root= insert(root, data); } if(key == 3) { printf("n---display ---n"); printf("nlevel datan"); prnt(root, 1); } if(key == 4) { printf("n---search ---n"); printf(" data---> "); scanf("%d", &sdata); temp= srch(root, sdata); }

이진검색트리(Binary Search Tree) if(key == 5) { printf("n---delete---n"); printf(" data---> "); scanf("%d", &sdata); root= delet(root, sdata); } if(key == 6) { printf("n---end---n"); } }while(key < 6); } //재귀적으로 트리를 순회하면서 입력위치를 결정

이진검색트리(Binary Search Tree) struct list *insert(struct list *rp, int data) { struct list *create_node(); if(rp == NULL) { //트리가 비어있는 상태 rp= create_node(); //하나의 노드를 할당받아 rp->data= data; rp->left= NULL; rp->right= NULL; }

이진검색트리(Binary Search Tree) else if( data == rp->data ) { //이미 데이터가 존재할 때 printf("n---------------n"); printf(“Existing data %dn”, data); printf("n---------------n"); } else if(data < rp->data ) //왼쪽 부트리로 이동 rp->left= insert(rp->left, data); else //오른쪽 부트리로 이동 rp->right= insert(rp->right, data); return(rp); }

이진검색트리(Binary Search Tree) struct list *create_node() { char *malloc(); return((struct list *)malloc(sizeof(struct list ))); }

이진검색트리(Binary Search Tree) void prnt(struct list *pp, int lev) { if(pp != NULL) { //중위 순회 알고리즘을 활용한 출력 prnt(pp->left, lev+1); printf("%2 d %-2 d n", lev, pp->data); prnt(pp->right, lev+1); } }

이진검색트리(Binary Search Tree) struct list *srch(struct list *sp, int data) { int cmp; if(sp != NULL) { if(data == sp->data) { printf("n data = %d n", sp->data); } else if(data < sp->data) sp->left= srch(sp->left, data); else sp->right= srch(sp->right, data); } else printf("Search Fail: %s is not exist in the tree n", data); return(sp); }

이진검색트리(Binary Search Tree) v Binary Search Tree의 구현 (Original version) #include "stdio. h" #include "string. h" #define YES 1 #define NO 0 #define LIST struct list LIST { LIST *left; char *name; char *tel; LIST *right; };

이진검색트리(Binary Search Tree) void main() { LIST *root, *insert(), *srch(), *modi(), *delet(), *temp; char name[15], tel[15]; int key; void prnt(), inp(); FILE *fp; root= NULL; do{ printf("n Input(file)-1 Input(keyboard)-2 Display-3 Search-4 Update-5 Delete-6 End-7 n"); printf("n Select a key --->"); scanf("%d", &key);

이진검색트리(Binary Search Tree) if(key == 1) { printf("n---input---n"); fp= fopen("binary. dat", "r"); if(fp != NULL) while(fscanf(fp, "%s %s", name, tel) != EOF) { printf("name=%s tel=%sn", name, tel); root= insert(root, name, tel); } else printf("fopen errorn"); }

이진검색트리(Binary Search Tree) if(key == 2) { // 키보드에서 삽입할 데이터값을 입력받음 inpt(name, tel); root= insert(root, name, tel); } if(key == 3) { printf("n---display ---n"); printf("nlevel name tel n"); prnt(root, 1); } if(key == 4) { printf("n---search ---n"); printf(" name---> "); scanf("%s", cname); temp= srch(root, cname); }

이진검색트리(Binary Search Tree) if(key == 5) { printf("n---update---n"); printf(" name---> "); scanf("%s", cname); modi(root, name); } if(key == 6) { printf("n---delete---n"); printf(" name---> "); scanf("%s", name); root= delet(root, name); }

이진검색트리(Binary Search Tree) LIST *insert(LIST *rp, char *name, char *tel) { LIST *create_node(); char *strsv(); int cmp; if(rp == NULL) { //트리가 비어있는 상태 rp= create_node(); //하나의 노드를 할당받아 rp->name= strsv(name); //데이터 필드와 연결필드를 설정 rp->tel= strsv(tel); rp->left= rp->right= NULL; }

이진검색트리(Binary Search Tree) else if((cmp=strcmp(name, rp->name)) == 0) { //이미 데이터가 존재 할 때 printf("n---------------n"); printf(“Existing NAME = %-15 s TEL= %-13 s n", rp->name, rp->tel); printf("n---------------n"); } else if(cmp < 0) //왼쪽 부트리로 이동 rp->left= insert(rp->left, name, tel); else //오른쪽 부트리로 이동 rp->right= insert(rp->right, name, tel); return(rp); }

이진검색트리(Binary Search Tree) void inpt(char *name, char *tel) { printf("nname ---> "); scanf("%s", name); printf("n tel--->"); scanf("%s", tel); } LIST *create_node() { char *malloc(); return((LIST *)malloc(sizeof(LIST))); }

이진검색트리(Binary Search Tree) char *strsv(char *sl) { //입력받은 데이터크기+1 만큼의 공간을 확보하여 데이터를 복사한다 char *p, *malloc(); if((p = malloc(strlen(sl) + 1)) != NULL) //EOL을 위한 공간 확보 strcpy(p, sl); return(p); } void prnt(LIST *pp, int lev) { if(pp != NULL) { //중위 순회 알고리즘을 활용한 출력 prnt(pp->left, lev+1); printf("%2 d %-14 s %15 s n", lev, pp->name, pp->tel); prnt(pp->right, lev+1); } }

이진검색트리(Binary Search Tree) LIST *srch(LIST *sp, char *snam) { int cmp; if(sp != NULL) { if((cmp=strcmp(snam, sp->name)) == 0) { printf("n name tel n"); printf("----------n"); printf("%-14 s %-15 s n", sp->name, sp->tel); } else if(cmp < 0) sp->left= srch(sp->left, snam); else sp->right= srch(sp->right, snam); } else printf("Search Fail: %s is not exist in the tree n", snam); return(sp); }

이진검색트리(Binary Search Tree) LIST *modi(LIST *mp, char *mnam) {char mtel[15]; int cmp; char *temp; if(mp != NULL) { if((cmp=strcmp(mnam, mp->name)) == 0) { printf("tel--> "); scanf("%s", mtel); temp= mp->tel; mp->tel= strsv(mtel); free(temp); } else if(cmp < 0) mp->left= modi(mp->left, mnam); else mp->right= modi(mp->right, mnam); } else printf("Search Fail: %s is not exist in the tree n", mnam); return(mp); }

이진트리(Binary Tree) 100 200 K I M . . …………… 1 2 3 4 ……………. LIST { LIST *left; char name[15]; char tel[15]; LIST *right; }; Vs. 100 200 300 K I M 400 ^ 400 1 2 3 LIST { LIST *left; char *name; char *tel; LIST *right; }; ^

이진트리(Binary Tree) 700 name 300 400 ^ 300 root insert(root, name, tel); 400 K I M 1 2 3 LIST *insert(LIST *rp, char *name, char *tel) 200 ^ tel void main() 100 200 800 500 600 ^ 500 A H A N 600 100 rp 800 tel 3 2 6 700 name strsv(name); char *strsv(char *sl) 700 sl

이진검색트리(Binary Search Tree)

이진검색트리(Binary Search Tree)

이진검색트리(Binary Search Tree)

이진검색트리(Binary Search Tree)

이진검색트리(Binary Search Tree) struct list *delet(struct list *dp, int data) // Simple version { struct list *findmin(), *temp; void free(); int i; if(dp == NULL) printf("Search Fail No search name exist n"); else if ((i= data – dp->data) < 0) dp->left= delet(dp->left, data); else if (i > 0) dp->right= delet(dp->right, data); else if(dp->left && dp->right) { // 삭제될 노드를 검색 temp= findmin(dp->right); //두개의 자식이 있는 노드 dp->data= temp->data; // 데이터의 복사 dp->right= delet(dp->right, dp->data); // 최소 노드를 결정한다 }

이진검색트리(Binary Search Tree) else { //하나의 자식 또는 없는 경우 temp= dp; if(dp->left == NULL) dp= dp->right; else if(dp->right == NULL) dp= dp->left; free(temp); } return(dp); }

이진검색트리(Binary Search Tree) struct list *findmin(struct list *node) { struct list *temp, *save; save= node; temp= save->left; //오른쪽 부트리의 최소값을 찾는다 while(temp != NULL) { save= temp; temp= temp->left; } return(save); }

이진검색트리(Binary Search Tree) LIST *delet(LIST *dp, char *dnam) // (Original Version) { LIST *findmin(), *temp; void free(); int cmp; if(dp == NULL) printf("Search Fail No search name exist n"); else if((cmp=strcmp(dnam, dp->name)) < 0) dp->left= delet(dp->left, dnam); else if(cmp > 0) dp->right= delet(dp->right, dnam); else if(dp->left && dp->right) { // 삭제될 노드를 검색 temp= findmin(dp->right); //두개의 자식이 있는 노드 strcpy(dp->name, temp->name); //데이터의 복사(크기문제발생) strcpy(dp->tel, temp->tel); //공간재설정 필요. 다음페이지 dp->right= delet(dp->right, dp->name); // 최소 노드를 결정한다 }

이진검색트리(Binary Search Tree) else if(dp->left && dp->right) { // 삭제될 노드를 검색 temp= findmin(dp->right); //두개의 자식이 있는 노드 free(dp->name); free(dp->tel); dp->name= strsv(temp->name); dp->tel= strsv(temp->tel); dp->right= delet(dp->right, dp->name); // 최소 노드를 결정한다 } // 정확한 메모리 크기 설정 코드

이진검색트리(Binary Search Tree) else { //하나의 자식 또는 없는 경우 temp= dp; if(dp->left == NULL) dp= dp->right; else if(dp->right == NULL) dp= dp->left; free(temp); } return(dp); }

이진검색트리(Binary Search Tree) LIST *findmin(LIST *node) { LIST *temp, *save; save= node; temp= save->left; //오른쪽 부트리의 최소값을 찾는다 while(temp != NULL) { save= temp; temp= temp->left; } return(save); }

AVL Tree

AVL Tree

AVL Tree

AVL Tree

AVL Tree

AVL Tree

AVL Tree

AVL Tree

AVL Tree v AVL 트리의 구현 #include "stdio. h" #include "string. h" #include "stdlib. h" #define YES 1 #define NO 0 #define AVL struct avl_node { struct avl_node *left; int data; // 데이터 값 int high; // 높이정보 struct avl_node *right; }; ^ 30 1 400 ^ 50 0 ^

AVL Tree void main() { struct avl_node *root, *srch(), *modi(), *temp; struct avl_node *delet(struct avl_node *dp, int key); int key, data; void prnt(struct avl_node *p, int lev); FILE *fp; struct avl_node *insert(struct avl_node *root, int data); root= NULL; do{ printf("n Input(file)-1 Input(keyboard)-2 Inorder-3 Search-4 Delete -5 End-6 n"); printf("n Select a key --->"); scanf("%d", &key);

AVL Tree if(key == 1) { printf("n ------- input -------n"); fp= fopen("avl. dat", "r"); if(fp != NULL) while(fscanf(fp, "%d", &data) != EOF) { printf("Data= %3 dn", data); root= insert(root, data); } else printf("fopen errorn"); } if(key == 2) { // 키보드에서 삽입할 데이터 값을 입력받음 scanf("%d", &data); printf("Data= %3 dn", data); root= insert(root, data); }

AVL Tree if(key == 3) { printf("n ------- Inorder -------n"); printf("n Height data n"); prnt(root, 1); } if(key == 4) { printf("n ------- search -------n"); printf(" Data---> "); scanf("%d", data); temp= srch(root, data); }

AVL Tree if(key == 5) { printf("n ------- delete -------n"); printf(" data---> "); scanf("%d", &data); root= delet(root, data); }

AVL Tree if(key == 6) { printf("n ------- end -------n"); } }while(key < 6); }

AVL Tree struct avl_node *insert(struct avl_node *tree, int data ) { struct avl_node *rotate_tree; int height(struct avl_node *node); struct avl_node *single_rotate_left(struct avl_node *p 2), *single_rotate_right(struct avl_node *p 2), *double_rotate_left(struct avl_node *p 3), *double_rotate_right(struct avl_node *p 3); if(tree == NULL) { 1 tree= (struct avl_node *)malloc(sizeof(struct avl_node)); if(tree == NULL) printf("Error: out of space n"); else { tree->data= data; tree-> high = 0; tree->left= NULL; tree->right= NULL; } }

AVL Tree else { if(data < tree->data) { tree->left= insert(tree->left, data); if((height(tree->left) - height(tree->right))== 2) { if(data < tree->left->data) rotate_tree= single_rotate_left(tree); 2 else rotate_tree= double_rotate_left(tree); tree= rotate_tree; } else tree->high = max(height(tree->left), height(tree->right)) + 1; }

AVL Tree else { tree->right= insert(tree->right, data); if((height(tree->right) - height(tree->left))== 2) { if(data > tree->right->data) rotate_tree= single_rotate_right(tree); else 3 rotate_tree= double_rotate_right(tree); tree= rotate_tree; // new subtree root } else tree->high = max(height(tree->left), height(tree->right)) + 1; } } return (tree); 4 }

AVL Tree int height(struct avl_node *node) { if(node == NULL) return (-1); else return (node->high); }

AVL Tree struct avl_node *single_rotate_left(struct avl_node *p 2) { struct avl_node *p 1; int height(struct avl_node *node); p 1= p 2 ->left; p 2 ->left= p 1 ->right; p 1 ->right= p 2; p 2 ->high = max(height(p 2 ->left), height(p 2 ->right)) + 1; p 1 ->high = max(height(p 1 ->left), p 2 ->high) + 1; return p 1; // new root }

AVL Tree struct avl_node *single_rotate_right(struct avl_node *p 2) { struct avl_node *p 1; int height(struct avl_node *node); p 1= p 2 ->right; p 2 ->right= p 1 ->left; p 1 ->left= p 2; p 2 ->high = max(height(p 2 ->right), height(p 2 ->left)) + 1; p 1 ->high = max(height(p 1 ->right), p 2 ->high) + 1; return p 1; // new root }

AVL Tree struct avl_node *double_rotate_left(struct avl_node *p 3) { // rotate between p 1 and p 2 p 3 ->left= single_rotate_right(p 3 ->left); //rotate between p 3 and p 2 return(single_rotate_left(p 3)); } struct avl_node *double_rotate_right(struct avl_node *p 3) { // rotate between p 1 and p 2 p 3 ->right= single_rotate_left(p 3 ->right); //rotate between p 3 and p 2 return(single_rotate_right(p 3)); }

AVL Tree struct avl_node *delet(struct avl_node *dp, int key) { struct avl_node *findmin(), *temp, *son, *rotate_tree; void free(); int height(struct avl_node *node); struct avl_node *findmin(struct avl_node *node); struct avl_node *single_rotate_left(struct avl_node *p 2), *single_rotate_right(struct avl_node *p 2), *double_rotate_left(struct avl_node *p 3), *double_rotate_right(struct avl_node *p 3), *delet(struct avl_node *dp, int key); if(dp == NULL) printf("Search Fail No search data exist n");

AVL Tree else if(dp->data > key) { dp->left= delet(dp->left, key); if((height(dp->right) - height(dp->left))== 2) { son= dp->right; // 오른쪽이 더 높은 경우 if(height(son->right) > height(son->left)) dp= single_rotate_right(dp); else dp= double_rotate_right(dp); } else dp->high = max(height(dp->left), height(dp->right)) + 1; }

AVL Tree else if(dp->data < key) { dp->right= delet(dp->right, key); if((height(dp->left) - height(dp->right))== 2) { son= dp->left; if(height(son->left) > height(son->right)) // 왼쪽이 더 높은 경우 dp= single_rotate_left(dp); else dp= double_rotate_left(dp); } else dp->high = max(height(dp->left), height(dp->right)) + 1; }

AVL Tree else if(dp->left && dp->right) { // 삭제될 노드(2개 자식) 를 검색 temp= findmin(dp->right); dp->data= temp->data; //데이터의 복사 dp->right= delet(dp->right, dp->data); // 최소 노드를 결정 //항상 오른쪽 에서 최소값이 삭제되므로 왼쪽이 길게된다 if((height(dp->left) - height(dp->right))== 2) { son= dp->left; if(height(son->left) > height(son->right)) dp= single_rotate_left(dp); else dp= double_rotate_left(dp); } else dp->high= max(height(dp->left), height(dp->right)) + 1; }

AVL Tree else { //자식이 하나 또는 없는 경우 temp= dp; if(dp->left == NULL) dp= dp->right; else if(dp->right == NULL) dp= dp->left; free(temp); } return(dp); }

AVL Tree struct avl_node *findmin(struct avl_node *node) { struct avl_node *temp, *save; save= node; temp= save->left; //오른쪽 부트리의 최소 값을 찾는다 while(temp != NULL) { save= temp; temp= temp->left; } return(save); }

AVL Tree void prnt(struct avl_node *p, int lev) { void prnt(struct avl_node *p, int lev); if(p != NULL) { //중위 순회 알고리즘을 활용한 출력 prnt(p->left, lev+1); printf("%2 d %3 d n", lev, p->data); prnt(p->right, lev+1); } }

AVL Tree struct avl_node *srch(struct avl_node *node, int key) { if(node != NULL) { if(node->data == key) { printf("n data %d found n", key); } else if(node->data > key) node->left= srch(node->left, key); else node->right= srch(node->right, key); } else printf("Search Fail: %d is not exist in the tree n", key); return(node); }

B-Tree

B-Tree

B-Tree 25를 삭제한 후 트리의 높이가 낮아짐 19 15 5, 8, 12 15, 18 27 21 19, 20 35 21, 22, 23 27, 28, 30 40 35, 37 40, 45

스레드 이진 트리(Thread Binary Tree)

스레드 이진 트리(Thread Binary Tree)

스레드 이진 트리(Thread Binary Tree)

스레드 이진 트리(Thread Binary Tree)

스레드 이진 트리(Thread Binary Tree) in_thread(struct thread *tree) { struct thread *node; node= tree; do { node= in_next(node); if(node != tree) printf("%c ", node->data); }while(node != tree); }

스레드 이진 트리(Thread Binary Tree) in_next(struct thread *current) { struct thread *inode; inode= current->r_child; if(!current->r_bit) //오른쪽 자식노드가 있으면 while(!inode->l_bit) //반복적으로 왼쪽끝 자식노드로 이동 inode= inode->l_child; return(inode); }

허프만 코드(Huffman code)

허프만 코드(Huffman code) v 예: ACABFEAFD 허프만 코드 0111010111101011100 24비트 동일한 크기 코드를 사용하는 경우 000 101 000 001 100 000 101 011 27비트

허프만 코드(Huffman code)

허프만 코드(Huffman code)

허프만 코드(Huffman code) 0 1 11 00 01 10 1100 111 1101