Föreläsning 5 Träd Binära träd Binärt sökträd som ADT Implementering av binärt sökträd Travestera binärt sökträd Sökning Insättning/borttagning
Terminologi - träd Ett träd i datalogi består av en rotnod och ett ändligt antal underträd (subtrees) Trädets höjd är antalet nivåer (4 i exemplet). nivå 0 nivå 1 nivå 2 nivå 3 Ett träd är en graf där man kan ta sig mellan två noder på endast ett sätt. N noder ger N-1 bågar. Vi kommer främst titta på binära träd.
Binära träd Ett binärt träd är ett träd där varje nod har maximalt 2 barn Definition: Ett binärt träd är antingen tomt eller så har rotnoden 2 underträd (subtree) som också är binära träd (vänster och höger underträd).
Binärt sökträd (BST) Ett binärt sökträd är ett binärt träd som är ordnat efter nodernas nycklar För godtycklig nod gäller alla nycklar i nodens vänstra underträdet är mindre än nodens nyckel alla nycklar i nodens högra underträdet är större än nodens nyckel vänster och höger underträd är också binära sökträd varje nod är unik (inga kopior)
Traversera Att besöka alla noder i ett träd kallas att traversera trädet. Tre traverseringsordningar: Inorder. Besök först trädets vänstra del, sedan noden själv och sist trädets högra del. (1,2,3,4,5,6,7) Preorder. Besök först noden själv, sedan trädets vänstra del och sist trädets högra del. (4,2,1,3,6,5,7) Postorder. Besök först trädets vänstra del, sedan trädets högra del och sist noden själv. (1,3,2,5,7,6,4) Normalt använder vi inorder.
Binärt sökträd som ADT Är skapat för att lätt kunna söka och lägga till och ta ut (log n). För att det ska fungera måste trädet vara bra balanserat. Operationer: searchtree(nyckel) inserttree(element) deletetree(nyckel)
binarysearchtree.h typedef struct{ char key[wordlength]; Data; typedef struct treenode TreeNode; struct treenode{ Data element; TreeNode *left, *right; ; typedef struct{ TreeNode *root; BinaryTree; BinaryTree *initbinarytree(); void inserttree(binarytree *bp,data e); void inorder(binarytree *bp); Data *searchtree(binarytree *bp,char key[]);
binarysearchtree.c - initiera #include <stdio.h> #include <stdlib.h> #include <assert.h> #include <string.h> #include "binarysearchtree.h" BinaryTree *initbinarytree() { BinaryTree *bp = (BinaryTree*)malloc(sizeof(BinaryTree)); bp->root = NULL; return bp;
binarysearchtree.c - traversera void inorder(binarytree *bp) { inordernode(bp->root); void inordernode(treenode *np) { if(np!=null) { inordernode(np->left); printf("%s,",(np->element).key); inordernode(np->right); Det här extrasteget hade vi sluppit om vi inte använt en speciell datastruktur för att representera ett träd utan helt enkelt använt en pekare av typen TreeNode och kallat den root. Det steget kommer nu behövas på alla funktioner vi väljer att lösa rekursivt.
binarysearchtree.c sätta in void inserttree(binarytree *bp,data e) { TreeNode *newnode = (TreeNode*)malloc(sizeof(TreeNode)); newnode->element = e; newnode->left=newnode->right=null; if(bp->root==null) bp->root=newnode; else insertnodeintree(bp->root,newnode);
binarysearchtree.c sätta in void insertnodeintree(treenode *tree,treenode *newnode) { int komp=strcmp((tree->element).key,(newnode->element).key); assert(komp!=0); if(komp<0) { if(tree->right==null) tree->right=newnode; else insertnodeintree(tree->right,newnode); else { if(tree->left==null) tree->left=newnode; else insertnodeintree(tree->left,newnode);
binarysearchtree.c - söka Data *searchtree(binarytree *bp,char key[]) { if(bp->root==null) return NULL; else { TreeNode *found = searchtreenode(bp->root, key); if(found!=null) return &(found->element); else return NULL;
binarysearchtree.c - söka TreeNode *searchtreenode(treenode *tree, char key[]) { int komp=strcmp((tree->element).key,key); if(komp==0) return tree; else if(komp<0){ if(tree->right==null) return NULL; else return searchtreenode(tree->right,key); else{ if(tree->left==null) return NULL; else return searchtreenode(tree->left,key);
Ta bort från binärt sökträd Det finns tre fall att ta hänsyn till när vi tar bort en nod: noden är ett löv noden har bara ett subträd noden har både vänster och höger subträd Fall 1 är trivialt: vi sätter helt enkelt förälderns relevanta subträd till NULL
Noden har bara ett subträd Också relativt enkelt. Vi ersätter helt enkelt noden med dess barn. Ex: Vi ska ta bort 4: 8 8 4 9 9 6 6 5 7 5 7
Noden har både vänster och höger subträd Vi måste nu lösa vad vi ska göra med de två barnen. Lösningen är att vi ersätter noden med den minsta noden i det högra underträdet. Denna kan inte ha något vänsterbarn (den är ju minst) och därmed lätta att ta bort (fall 2) Ex: vi vill ta bort nod B. H H B N C N A E A E C F F D D
deletenode För att implementera deletetree kommer vi att skapa en intern hjälpfunktion som tar som parameter en pekare till noden som ska tas bort och returnerar en pekare till rotnoden till det nya subträdet. I exemplet nedan skickar man in en pekare till B och funktionen returnerar en pekare till C med underträdet i den högra bilden: H H B N C N A E A E C F F D D
deletenode - hjälpfunktion TreeNode *deletenode(treenode *np){ TreeNode *newsubtree; if(np==null) return NULL; else if(np->right==null){ H newsubtree=np->left; B free(np); return newsubtree; A else if(np->left==null){ H newsubtree=np->right; B free(np); return newsubtree; E else{ N N
hjälpfunktion forts. TreeNode *parenttomin; TreeNode *minofrighttree; H minofrighttree = np->right; if(minofrighttree->left==null){ B N minofrighttree->left=np->left; free(np); A E return minofrighttree; F while(minofrighttree->left!=null){ parenttomin = minofrighttree; minofrighttree = minofrighttree->left; min parenttomin->left = minofrighttree->right; minofrighttree->left=np->left; minofrighttree->right=np->right; free(np); return minofrighttree; A B C E D H F N parent
deletenode -gränssnittsfunktion Data deletetree(binarytree *bp,char key[]){ Data d; bp->root=deletenodetree(bp->root,key,&d); return d; Observera hur deletnodetree ska returnera en pekare till hela det nya trädet! Den kommer sedan rekursivt leta sig ner i trädet mot rätt nod och hela tiden returnera en pekare till trädet där den är tills den hittar rätt nod. Då skickar den denna till vår hjälpfunktion som returnerar en pekare till det nya trädet.
deletenode söker upp rätt nod TreeNode *deletenodetree(treenode *tree,char key[],data *d){ int komp=strcmp((tree->element).key,key); if(komp==0){ *d = tree->element; return deletenode(tree); else if(komp<0){ if(tree->right==null) return tree;//fanns ej else{ tree->right = deletenodetree(tree->right,key,d); return tree; else{ if(tree->left==null) return tree;//fanns ej else{ tree->left = deletenodetree(tree->left,key,d); return tree;
Inlämningsuppgifter Följande uppgifter redovisas senast måndag den 6 februari och kan inte redovisas senare: 5.5, 5.A, 5.B, 5.C/5.7, 5.D, 5.E Dessa uppgifter bör göras nu för att ni ska kunna följa kursen på ett bra sätt. Övriga kan ni göra vid tillfälle för högre betyg.
Uppgifter ej i boken Utgå från föreläsningens implementering av ett binärt sökträd när du löser nedanstående uppgifter 5.A Skriv en main som läser in sju ord från användaren och placerar dessa i ett BST. Kör programmet och skriv in 7 ord så att trädet får minsta möjliga höjd. Kör programmet och skriv in 7 ord så att trädet får maximal höjd. (2p) 5.B Skriv funktioner som traverserar trädet med preorder och inorder. (1p) 5.C Skriv två funktioner numberofleaves och numberofnodes till vår implementation från föreläsningen. (2p) 5.D Skriv om sökfunktionen så att den är iterativ istället för rekursiv. (3p) 5.E Skriv en funktion maximum som returnerar det största värdet i ett binärt sökträd. Skriv en rekursiv och en iterativ version. (2p)