BINÄRA TRÄD. (X = pekarvärdet NULL): struct int_bt_node *pivot, *ny; X X X 12 X X 12 X X -3 X X

Transkript

1 Algoritmer och Datastrukturer Kary FRÄMLING/Göran PULKKIS (v23) Kap. 7, Sid 1 BINÄRA TRÄD Träd används för att representera olika slags hierarkier som ordnats på något sätt. Den mest använda trädstrukturen är binära träd, i vilka varje nod kan ha noll, en eller två söner. Följande postdefinition kan användas för att lagra heltal i ett binärt träd: struct int_bt_node int i; struct int_bt_node struct int_bt_node ; *left; *right; Pekaren "left" pekar sålunda till det vänstra delträdet om ett sådant finns och "right" pekar till det högra delträdet om ett sådant finns. Träd kan användas för snabb lagring av och snabb sökning i sorterad data. Ett binärt träd av heltalen,,, -8, 6, 6 byggs upp så, att placeras i trädets rotnod och därefter insätts ett mindre tal till vänster om en nod och ett icke mindre tal till höger. Detta illustreras nedan ( = pekarvärdet NULL): struct int_bt_node *pivot, *ny; tomt träd lägg till lägg till lägg till 3

2 Algoritmer och Datastrukturer Kary FRÄMLING/Göran PULKKIS (v23) Kap. 7, Sid 2 lägg till 8-8 Lägg till Lägg till Insättning av ett talvärde (t.ex.) i det binära trädet kan programmeras med om funktionen add_tal är definierad som pivot = add_tal(,pivot);

3 Algoritmer och Datastrukturer Kary FRÄMLING/Göran PULKKIS (v23) Kap. 7, Sid 3 struct int_bt_node *add_tal(int tal, struct int_bt_node *trad) struct int_bt_node *ny; ny = (struct int_bt_node *)malloc(sizeof(struct int_bt_node)); ny->i = tal; ny->left = ny->right = NULL; return add_nod(ny,trad); och funktionen add_nod är rekursivt definierad som struct int_bt_node *add_nod(struct int_bt_node *nynod, struct int_bt_node *gamtrad) if (gamtrad == NULL) return nynod; if (nynod->i < gamtrad->i) gamtrad->left = add_nod(nynod,gamtrad->left); else gamtrad->right = add_nod(nynod,gamtrad->right); return gamtrad; Heltalen sparas sorterade i det binära trädet. Utskrift av varje heltal på egen rad börjande från det minsta heltalet sker med anrop av de rekursiva funktionen void visa(struct int_bt_nod *rot) if (rot!= NULL) visa(rot->left); printf( %d\n,rot->i); visa(rot->right); Exempel 1. Modulärt programmerat binärt träd för sortering av bokstäver (kompilerat och kört). /* BinTree.h */ typedef struct bt_node char c; struct bt_node *left; struct bt_node *right; BinTreeNode; typedef struct BinTreeNode *pivot; BinTree; BinTree *newbintree(void); int add(bintree *bt, char c); int removenode(bintree *bt, char c); void show(bintree *bt); void freebintree(bintree *bt);

4 Algoritmer och Datastrukturer Kary FRÄMLING/Göran PULKKIS (v23) Kap. 7, Sid 4 /* BTmain.c */ #include <stdio.h> #include <string.h> #include "BinTree.h" main() BinTree *bt; char inp_str[] = "hejsan allihopa!"; int i; /* Vi skapar en ny ko */ bt = newbintree(); /* Vi satter in hela teckenstrangen */ for ( i = ; i < strlen(inp_str) ; i++ ) add(bt, inp_str[i]); /* Visa tradets innehall */ show(bt); /* Frigor minnet */ freebintree(bt); /* BinTree.c */ #include <stdio.h> #include <stdlib.h> #include "BinTree.h" static void recadd(bintreenode **root, BinTreeNode *newnode); static void recshow(bintreenode *root); static void recfree(bintreenode *root); BinTree *newbintree(void) return (BinTree*) calloc(1, sizeof(bintree)); int add(bintree *bt, char c) BinTreeNode *new_node; new_node = (BinTreeNode*) calloc(1, sizeof(bintreenode)); new_node->c = c; if ( new_node == NULL ) return ; recadd(&bt->pivot, new_node); return 1; void show(bintree *bt) recshow(bt->pivot); printf("\n");

5 Algoritmer och Datastrukturer Kary FRÄMLING/Göran PULKKIS (v23) Kap. 7, Sid 5 void freebintree(bintree *bt) recfree(bt->pivot); bt->pivot = NULL; static void recadd(bintreenode **root, BinTreeNode *newnode) if ( *root == NULL ) *root = newnode; else if ( (*root)->c > newnode->c ) recadd(&(*root)->left, newnode); else recadd(&(*root)->right, newnode); static void recshow(bintreenode *root) if ( root!= NULL ) recshow(root->left); putchar(root->c); recshow(root->right); static void recfree(bintreenode *root) if ( root!= NULL ) recfree(root->left); recfree(root->right); free(root); Programmet körs:!aaaehhijllnops Programmet sorterar alltså tecknen i teckensträngen "hejsan allihopa!", vilket fungerar fint i och med att vi endast har små tecken som finns i det engelska alfabetet. Alla operationer på trädet görs rekusivt, vilket är typiskt för trädstrukturer. Den algoritm som systematiskt används här kallas för "depth-first" eftersom den alltid går till ändan på varje gren före den fortsätter med följande. En annan algoritm som kallas för "breadth-first" går igenom trädet en nivå i taget. Insättningen av en ny nod är en relativt enkel operation. Däremot är det mera komplicerat att plocka bort en nod, eftersom vi måste behandla tre specialfall skilt, d.v.s. om noden har noll, en eller två söner.

6 Algoritmer och Datastrukturer Kary FRÄMLING/Göran PULKKIS (v23) Kap. 7, Sid 6 För att implementera borttagandet av en nod börjar tilläggs följande funktionsdeklarationer i filen "BinTree.c": static BinTreeNode *recremove(bintreenode *node, char c); static BinTreeNode *findmin(bintreenode *node); Sedan modifieras "main"-funktionen så att två bokstäver plockas bort från trädet, varefter trädets innehåll visas pånytt: /* Plocka bort ett par noder och visa panytt. */ removenode(bt, 'a'); removenode(bt, 'i'); show(bt); Funktionsdefinitionerna ser ut enligt följande: int removenode(bintree *bt, char c) if ( bt == NULL bt->pivot == NULL ) return ; return ( recremove(bt->pivot, c) == NULL )? : 1; static BinTreeNode *recremove(bintreenode *node, char c) BinTreeNode *tmp, *child; if ( node == NULL ) return NULL; /* Icke hittad! */ else if ( c < node->c ) /* Vanster */ node->left = recremove(node->left, c); else if ( c > node->c ) /* Hoger */ node->right = recremove(node->right, c); else if ( node->left && node ->right ) /* Tva soner */ tmp = findmin(node->right); node->c = tmp->c; node->right = recremove(node->right, node->c); else /* En eller ingen son */ tmp = node; if ( node->left == NULL ) child = node->right; if ( node->right == NULL ) child = node->left; free(tmp); return child; return node; static BinTreeNode *findmin(bintreenode *node) while ( node->left!= NULL ) node = node->left; return node; Först granskas att trädet existerar och att det inte är tomt. Annars söks den nod som skall förstöras.

7 Algoritmer och Datastrukturer Kary FRÄMLING/Göran PULKKIS (v23) Kap. 7, Sid 7 I det här exemplet antas att noden hittas. Om noden inte hittas fungerar detta program inte alltid rätt! Principen för borttagning av en nod för de tre möjliga fallen är följande: 1. Inga söner: noden kan tas bort direkt och NULL returneras som nytt pekarvärde. 2. En son: noden kan tas bort direkt och pekaren till nodens son returneras. 3. Två söner: den minsta noden n min i det högra delträdet uppsökes, dess värde ersätter det gamla värdet för den nod som skall tas bort, varefter vi kan plocka bort noden n min. Andra mycket använda trädstrukturer är så kallade "B-trees", vars noder kan ha flera än två söner. Detta kan vara fördelaktigt för att göra det skapade trädet mera balanserat t.ex. för sökning. Sorteringen som utförs i föregående exempel ger ett välbalanserat träd om den första bokstaven råkar vara ungefär i mitten av alfabetet. I ett sådant träd blir framförallt sökning mycket effektivt. Om bokstäverna däremot är färdigt sorterade får vi ett helt obalanserat träd. För att undvika detta har algoritmer utvecklats för att balansera träd. Dessa behandlas dock inte i denna kurs.