Lecture VIII Keywords: tree-based data structures; binary search trees; red/black trees; flexible functional arrays; heaps; priority queues.

Transcription

1 Bar search trees Lecture VIII Kewords: tree-based data structures; bar search trees; red/black trees; fleible functional arras; heaps; priorit queues. References: [MLWP, Chapters 4 and 7] [PFDS, Chapters 2( 2), 3( 3), and 5( 2)] A bar search tree is a bar tree with nodes where data items are stored with the propert that, Thus, for ever node the tree, the elements of the left subtree are smaller than or equal to that of the node which turn is smaller than the elements of the right subtree. the order listg of a bar search tree is a sorted list. / 1 / 2 Applications: 1. Bar search trees offer a simple wa to represent sets; which case, to elimate repetitions, it is natural to impose the etra condition that elements of left subtrees are strictl smaller than their respective roots. When balanced, the admit O(n log n) runtime for all basic operations. 2. Bar search trees can also be easil etended to act as dictionaries, mappg kes to values. We can test membership a bar search tree usg lookup: fun lookup empt = false lookup ( node(v,l,r) ) = ( = v ) orelse ( if < v then (lookup l) else ( lookup r ) ) ; val lookup = fn : t -> t tree -> bool / 3 / 4

2 To sert a new value, we just need to fd its proper place: fun sert empt = node(, empt, empt ) sert ( node(v,l,r) ) = if <= v then node( v, sert l, r ) else node( v, l, sert r ) ; val sert = fn : t -> t tree -> t tree We could thus sort a list b the followg procedure: val sort = order o ( foldl ( fn(,t) => sert t ) empt ) ; val sort = fn : t list -> t list Red/Black trees Bar search trees are simple and perform well on random or unordered data, but the perform poorl on ordered data, degradg to O(n) performance for common operations. Red/black trees are a popular famil of balanced bar search trees. Ever node a red/black tree is colored either red or black. datatpe a RBtree = O R of a * a RBtree * a RBtree B of a * a RBtree * a RBtree ; NB: Empt nodes are considered to be black. / 5 / 6 Red/Black tree sert We sist that ever red/black tree satisfies the followg two balance variants: 1. No red node has a red child. 2. Ever path from the root to an empt node contas the same number of black nodes. Together, these variants ensure that the longest possible path, one with alternatg black and red nodes, is no more than twice as long as the shortest possible path, one with black nodes onl. fun RBsert t = let fun s( O ) = R(, O, O ) (*1*) s( R(, l, r ) ) = if <= then R(, s l, r ) else R(, l, s r ) s( B(, l, r ) ) = if <= then BALANCE( B(, s l, r ) ) (*3*) else BALANCE( B(, l, s r ) ) ; (*3*) case s t of R(,l,r) => B(,l,r) (*2*) t => t / 7 / 8

3 This function etends the sert function for unbalanced search trees three significant was. 1. When we create a new node, we itiall color it red. 2. We force the fal root to be black, regardless of the color returned b s. 3. We clude calls to a BALANCE function, that massages its arguments as dicated the figure on the followg page to enforce the balance variants. NB: We allow a sgle red-red violation at a time, and percolate this violation up the search path towards the root durg rebalancg. t 4 t 2 t 3 t 4 t 3 t 2 t 2 t 3 t 4 t 2 t 2 t 3 t 4 / 9 t 3 t 4 / 10 fun BALANCE ( B(, R(, R(, t1, t2 ), t3 ), t4 ) B(, R(, t1, R(, t2, t3 ) ), t4 ) B(, t1, R(, t2, R(, t3, t4 ) ) ) B(, t1, R(, R(, t2, t3 ), t4) ) ) = R(, B(, t1, t2 ), B(, t3, t4 ) ) BALANCE t = t ; val BALANCE = fn : a RBtree -> a RBtree Functional arras A functional arra provides a mappg from an itial segment of natural numbers to elements, together with lookup and update operations. A fleible arra augments the above operations to sert or delete elements from either end of the arra. signature UpperFleARRAY = sig tpe a t eception Subscript val empt: a t val null: a t -> bool val length: a t -> t val lookup: a t * t -> a val update: a t * t * a -> a t val shrk: a t -> a t / 11 / 12

4 We will provide an implementation based on the followg tree-based data structure. structure TreeArraMod = struct abstpe a t = O V of a * a t * a t with eception Subscript ; val empt = O ; fun lookup( V(v,tl,tr), k ) = if k = 1 then v else if k mod 2 = 0 then lookup( tl, k div 2 ) else lookup( tr, k div 2 ) lookup( O, _ ) = raise Subscript ; fun update( O, k, v ) = if k = 1 then ( V(v,O,O), 1 ) else raise Subscript update( V(,tl,tr), k, v ) = if k = 1 then ( V(v,tl,tr), 0 ) else if k mod 2 = 0 then let val (t,i) = update(tl,k div 2,v) ( V(,t,tr), i ) end else let val (t,i) = update(tr,k div 2,v) ( V(,tl,t), i ) / 13 / 14 An implementation of upper fleible functional arras follows. fun delete( O, n ) = raise Subscript delete( V(v,tl,tr), n ) = if n = 1 then O else if n mod 2 = 0 then V( v, delete(tl,n div 2), tr ) else V( v, tl, delete(tr,n div 2) ) ; NB: The implementation can be etended to also provide downwards fleibilit logarithmic time. Consider this as an eercise, or consult [MLWP, 4.15]. structure TreeArra : UpperFleARRAY = struct abstpe a t = A of t * a TreeArraMod.t with eception Subscript ; val empt = A( 0, TreeArraMod.empt ) ; fun null( A(l,_) ) = l = 0 ; fun length( A(l,_) ) = l ; / 15 / 16

5 fun lookup( A(l,t), k ) = if l = 0 orelse ( k < 1 andalso k > l ) then raise Subscript else TreeArraMod.lookup(t,k) ; fun update( A(l,t), k, v ) = if 1 <= k andalso k <= l+1 then let val (u,i) = TreeArraMod.update( t, k, v ) A( l+i, u ) end else raise Subscript ; fun shrk( A(l,t) ) = if l = 0 then empt else A( l-1, TreeArraMod.delete(t,l) ) ; / 17 / 18 Priorit queues usg heaps A priorit queue is an ordered collection of items. Items ma be serted an order, but onl the highest priorit item (tpicall taken to be that with lower numerical value) ma be seen or deleted. signature PRIORITY_QUEUE = sig eception Sie tpe item tpe t val empt: t val null: t -> bool val sert: item -> t -> t val m: t -> item val delm: t -> t A heap is a bar tree which the labels are arranged so that ever label is less than or equal to all labels below it the tree. This heap condition puts the labels no strict order, but does put the least label at the root. The followg functional priorit queues are based on fleible arras that are heaps. structure Heap: PRIORITY_QUEUE = struct eception Sie ; tpe item = real ; abstpe a tree = O V of a * a tree * a tree with tpe t = item tree ; / 19 / 20

6 val empt = O ; fun null O = true null _ = false ; fun sert (w:item) O = V( w, O, O ) sert w ( V( v, l, r ) ) = if w <= v then V( w, sert v r, l ) else V( v, sert w r, l ) ; fun m( V(v,_,_) ) = v m O = raise Sie ; local eception Impossible ; fun leftrem( V( v, O, O ) ) = ( v, O ) leftrem( V( v, l, r ) ) = let val (w,t) = leftrem l ( w, V(v,r,t) ) end leftrem _ = raise Impossible ; / 21 / 22 fun siftdown( w:item, O, O ) = V( w, O, O ) siftdown( w, t as V(v,O,O), O ) = if w <= v then V( w, t, O ) else V( v, V(w,O,O), O ) siftdown( w, l as V(u,ll,lr), r as V(v,rl,rr) ) = if w <= u andalso w <= v then V(w,l,r) else if u <= v then V( u, siftdown(w,ll,lr),r) else V( v, l, siftdown(w,rl,rr) ) siftdown _ = raise Impossible ; fun delm O = raise Sie delm( V(v,O,_) ) = O delm( V(v,l,r) ) = let val (w,t) = leftrem l siftdown( w, r, t ) end / 23 / 24

7 Heap sort fun heaptolist h = if Heap.null h then [] else (Heap.m h) :: heaptolist(heap.delm h) ; val sort = heaptolist o foldl (fn(v,h) => Heap.sert v h) Heap.empt ; / 25