1 Träd nr 11 Binära träd ordnade, traversering, sökning.

En presentation över ämnet: "1 Träd nr 11 Binära träd ordnade, traversering, sökning."— Presentationens avskrift:

1 1 Träd nr 11 Binära träd ordnade, traversering, sökning

2 2 Binära träd Ett träd är en datatyp som består av en hierarki av noder. Varje nod består av ett värde och grenar till delträd. I ordnade träd bestäms placering av värdena i delträden av en relation mellan värdena och nodens värde. Det översta värdet kallas rot. I binära träd har varje nod två delträd, vänster och höger delträd.

3 3 Datatypen binära träd Ett binärt träd är antingen –tomt eller –en nod som består av ett värde och vänster och höger delträd datatype 'a tree = empty | node of 'a * 'a tree * 'a tree datatype 'a tree con node : ('a * 'a tree * 'a tree) -> 'a tree con empty : 'a tree I ett ordnat binärt träd (ett sökträd) så är alla värden i vänster delträd "mindre" än i noden och alla i höger "större", enligt någon ordning. type 'a order = 'a -> 'a -> bool

4 4 Insättning i ett ordnat binärt träd fun add less v empty = node (v,empty,empty) | add (less: 'a order) v (node(nv, left,right)) = if less v nv then node (nv,add less v left,right) else node (nv, left, add less v right) > val add = fn : 'a order -> 'a -> 'a tree -> 'a tree fun iless (n:int) m = n < m > val iless = fn : int -> (int -> bool) val iadd = add iless > val iadd = fn : int -> (int tree -> int tree)

5 5 Traversering av träd (från träd till lista) Inorder: först vänster delträd, sen roten och sist höger fun inorder empty = [] | inorder (node (v,l,r)) = inorder l @ v :: inorder r > val inorder = fn : 'a tree -> 'a list Preorder: först roten, sen vänster delträd och sist höger fun preorder empty = [] | preorder (node (v,l,r)) = v :: preorder l @ preorder r > val preorder = fn : 'a tree -> 'a list Postorder: först vänster, sen höger och sist roten fun postorder empty = [] | postorder (node (v,l,r)) = postorder l @ postorder r @ [v] > val postorder = fn : 'a tree -> 'a list

6 6 Fler funktioner på träd fun depth empty = 0 | depth (node (nv, left, right)) = 1 + max (depth left) (depth right); > val depth = fn : 'a tree -> int fun mirror empty = empty | mirror (node (nv, left, right)) = node (nv, mirror right, mirror left); > val mirror = fn : 'a tree -> 'a tree fun treesort order = inorder  reduce (add order) empty val treesort = fn : 'a order -> 'a list -> 'a list

7 7 Sökning Utnyttja ordning för att ger snabbare sökning fun in_tree less v empty = false | in_tree (less: ''a order) v (node (nv, l, r)) = let val in_sub = in_tree less v in v = nv orelse if less v nv then in_sub l else in_sub r end > val in_tree = fn : ''a order -> ''a -> ''a tree -> bool

8 8 Alternativ definition fun in_tree (less: ''a order) v = let fun in_t empty = false | in_t (node (nv,l,r)) = v = nv orelse if less v nv then in_t l else in_t r in in_t end > val in_tree = fn : ''a order -> ''a -> ''a tree -> bool

9 9 Avgöra om ett villkor uppfylls av ett träd Djupet först fun dfind p empty = false | dfind p (node (v, l, r)) = p v orelse dfind p l orelse dfind p r > val dfind = fn : ('a -> bool) -> 'a tree -> bool Bredden först fun bfind p t = let fun bp nil = false | bp (empty :: xs) = bp xs | bp (node (v, l, r) :: xs) = p v orelse bp (xs @ [l,r]) in bp [t] end val bfind = fn : ('a -> bool) -> 'a tree -> bool

10 10 Lövade träd datatype 'a ltree = leaf of 'a | node of 'a ltree * 'a ltree datatype 'a ltree con node : ('a ltree * 'a ltree) -> 'a ltree con leaf : 'a -> 'a ltree fun rand (leaf x) = [x] | rand (node (l,r)) = rand l @ rand r > val rand = fn : 'a ltree -> 'a list fun randa xs (leaf x) = x :: xs | randa xs (node (l,r)) = randa (randa xs r) l > val randa = fn : 'a list -> ('a ltree -> 'a list)

11 11 Fullständiga träd datatype ('a,'b) ftree = leaf of 'a | fnode of 'b * ('a,'b) ftree * ('a,'b) ftree datatype oper = plus | times | minus | div type val = int type expr = (val,oper) ftree fun eval (leaf n : expr) : int = n | eval (fnode (oper,l,r)) = let val lv = eval l val rv = eval r in case oper of plus => lv + rv | minus => lv - rv | times => lv * rv … end