Datové struktury a algoritmy Část 5 Ab straktní datové typy

1. Datové struktury a algoritmyČást 5Abstraktní datové typy Petr Felkel

2. Data structures and algorithmsPart 5Abstract data types Petr Felkel

3. Abstraktní datové typy • Abstrahují od jak? • Jak jsou data zobrazena v paměti… • Jak jsou prováděny operace… • Zdůrazňují co? • Co s nimi operace s daty provádějí nezávisle na konkrétní implementaci

4. Abstract data types • Abstract from:How? • How is the data stored in memory? • How are the operations executed? • Emphasize:What? • What do the operations do with the data (independent of any particular implementation)?

5. Abstraktní datové typy • Fronta (Queue) • Zásobník (Stack) • Pole (Array) • Tabulka (Table) • Seznam (List) • Strom (Tree) • Množina (Set)

6. Seznam (List) • Posloupnost údajů • Ukazovátko • Pouze v místě ukazovátka lze přidat / zrušit / aktualizovat prvek • Homogenní, lineární, dynamická

7. List (Seznam) • Sequence of items • Marker • Insert, delete, update only where points the marker • Homogeneous, linear, dynamic

8. init read Elem List length Nat empty, full Bool insert delete, first,last next,prev List (Seznam)

9. List (Seznam) • init: -> List • insert(_,_): Elem, List -> List • read(_): List -> Elem • delete(_), • first(_), last(_) • next(_), prev(_): List -> List • length(_): List -> Nat • empty(_), full(_) • atbeg(_), atend(_): List -> Bool

10. List (Seznam) • Pomocný druh • Seq = posloupnost bez ukazovátka • Pomocné operace: • new: -> Seq ... prázdná posloupnost • cons(_,_): Elem, Seq -> Seq • cons2(_,_): Elem, List -> List • ... vlož do čela • mark(_): Seq -> List ... ukaz. do čela

11. a b c d List (Seznam) Example: cons2( a, cons2( b, mark( cons( c, cons( d, new )))))

12. x x x a b c d a b c d a b c d x a b c d a b c d List – insert Where to insert? Where to leave the marker?

13. a b c d a b d List – delete Where to leave the marker? On the next a b d On the previous

14. x x x y y x List (Seznam) • var: x,y:Elem, s:Seq, l:List • init = mark( new ) • insert( x, mark(s) ) • = cons2( x, mark(s)) • ... Insert BEFORE the pointer • insert( x, cons2( y, l ))= • cons2( y, insert( x,l))

15. x x List (Seznam) • delete( init ) = init • delete( mark( cons( x, s))) • = mark( s ) • ... delete by the pointer • delete( cons2( x, l )) = • cons2( x, delete( l )) • ... delete by the pointer x

16. List (Seznam) • next( init ) = init • next( mark( cons( x, s ) ) ) = • cons2( x, mark( s ) ) • next( cons2( x, l ) ) = • cons2( x, next( l ) ) x x ... pointer move x x ..no change before

17. List (Seznam) • prev( mark(s) ) = mark(s) • prev( cons2( x, mark( s ) ) ) = • mark( cons( x, s )) • prev( cons2( x, cons2( y, l ))) = • cons2( x, prev( cons2( y, l ))) x x ... move by head y x y x ... move inside

18. x List (Seznam) • first( mark(s) ) = mark(s) • first( cons2( x, l ) ) = • first( prev( cons2( x, l ) ) ) ... no move by head x ... move step by step to front

19. List (Seznam) • last( init ) = init • last( mark( cons( x, s ) ) ) = • cons2( x, last( mark( s ) ) ) • last( cons2( x, l ) ) = • cons2( x, last( l ) ) x x ... moveback x x …no change before

20. List (Seznam) • read( init ) = error_elem • read( cons2( x, l ) = read( l ) • read( mark( cons( x, s ))) = x

21. List (Seznam) • length( init ) = 0 • length( cons2( x, l )) = • succ( length(l ) ) • length( mark( cons( x, s ))) = • succ( length( mark( s ))) ... elements before the pointer ... elements after the pointer

22. List (Seznam) • empty( l) = ( length( l ) == 0 ) • full( l) = ( length( l ) == max ) • atbeg( mark( s)) = true • atbeg( cons2( x, l )) = false • atend( mark( new)) = true • atend( mark( cons( x, s )))= false • atend( cons2( x, l )) = atend( l )

23. 0 1 2 3 4 5 A B C D point tail 0 1 2 3 4 5 C A B C D A B D point (tail) point List implementation In ArrayO(n) insert, delete O(1) first, last, prev, next In Array (head) Stacks in ArrayO(1) insert, delete, prev, next O(n) first, last, … (head)

24. head tail A B C point len 3 head tail point A B C len 3 A B C 3 List implementation O(1) insert, O(1)..O(n) delete O(1) first, last, prev, next - memory for pointers In Dynamic memory Linked list Double linked list Circular double linked list head tail point len

25. Linked list List implementation list::insert( elem x) { item *help = new item; if( point == NULL ){ //point behind help->next = NULL; help->val = x; if( tail == NULL ) //empty list head = help; else //add at end tail->next = help; tail = help; } //point still points behind list! else { //point in the list - trick help->val = point->val; help->next = point->next; point->next = help; point->val = x; point = help; } len++; } head tail A B C point len 3 help head tail A x B C point len 3

26. help head tail A B C point len 3 Linked list help help head tail A B C D point 4 len head tail A B D D point len 3 List implementation list::delete( ) { item *help; if( point != NULL ){ //behind ignore if( point->next == NULL ) { //last help = head; //find predecessor while( help->next != point ) help = help->next; } help->next = NULL; point = NULL; delete( tail ); tail = help; } else {// trick: skip predec.search help = point->next; *point = *help; if( help == tail ) tail = point; delete( help ); } len--; } }

27. Linked list List implementation list::prev() { item *help; if( point != head){//point can move help = head; while( help->next != point ) help = help->next; point = help; } } head tail A B C point len 3 help head tail A x B C point len 4

28. Double linked list head tail point A B C len 3 List implementation list::prev() { item *help; if( point != head){//point can move point = point->prev; } } Prev is the only place to save!

29. Double linked list head tail point A B C len 3 List implementation list::delete( ) { item *help; if( point != NULL ){ //behind ignore help = point->next ; if( head == point ) //first elem head = help; if( tail == point ) //last elem tail = tail->prev; if( help != NULL ) //update prev help->prev = point->prev; //update next if( point->prev != NULL ); point->prev->next = help; delete( point ); point = help; len--; } }

30. A List implementation Circular double linked list list::delete( ) { item *help; if( point != list ){ //not at end point->prev->next = point->next; point->next->prev = point->prev; help = point; point = point->next; delete( help ); len--; } } list::prev() { if( !atBegin() ) //point!=list->head point = point->prev; } head tail B C list point 3 len help

31. Abstraktní datové typy • Fronta (Queue) • Zásobník (Stack) • Pole (Array) • Tabulka (Table) • Seznam (List) • Strom (Tree) • Množina (Set)

32. Strom (Tree) • Kdy? • řazení, vyhledávání, vyhodnocování výrazů, ... • acyklický souvislý graf • kořenový strom • orientovaný strom, zvláštní uzel - kořen • kořen spojen se všemi uzly orient. cestou • binární strom - má 0, (1), 2 následníky • uspořádaný binární strom - dvojice <u, u1> a <u, u2> jsou uspořádány

33. Tree (Strom) • When? • sorting, searching, evaluation of expressions, ... • acyclic connected graph • root tree • oriented tree, special node - root • root connected to all nodes by oriented path • binary tree - has 0, (1), 2 successors • ordered binary tree - pairs <u, u1> and <u, u2> are ordered

34. Strom (Tree) • uzel - více následníků • binární strom - 2 následníci • následník - opět strom • homogenní, nelineární, dynamická

35. Tree (Strom) • node - more successors • binary tree - 2 successors • successor - also a tree • homogeneous, nonlinear, dynamic

36. empty info Elem Tree null leaf Bool cons left, right setleft, setright Binární strom (Tree)

37. Binární strom (Tree) • empty: -> Tree • leaf(_): Elem -> Tree • cons(_,_,_): Elem, Tree, Tree • ->Tree • left(_), right(_): Tree -> Tree • null(_): Tree -> Bool • setleft, setright(_,_): Tree, • Tree -> Tree • setinfo( Tree, Elem ): -> Tree • info(_): Tree -> Elem

38. Binární strom (Tree) • var x: Elem; a,b,t: tree • leaf( x ) = cons( x, empty, empty) • left( empty ) = error_tree • left( cons( x, a, b)) = a • right( empty ) = error_tree • right( cons( x, a, b)) = b

39. Binární strom (Tree) • null( empty ) = true • null( cons( x, a, b)) = false • setleft( empty, t ) = error_tree • setleft( cons( x, a, b ), t ) = • cons( x, t, b ) • setright( empty, t ) = error_tree • setright( cons( x, a, b ), t ) = • cons( x, a, t )

40. Binární strom (Tree) • setinfo( empty, x ) = error_tree • setinfo( cons( x, a, b ), y ) = • cons( y, a, b ) • info( empty ) = error_elem • info( cons( x, a, b ) ) = x

41. Abstraktní datové typy • Fronta (Queue) • Zásobník (Stack) • Pole (Array) • Tabulka (Table) • Seznam (List) • Strom (Tree) • Množina (Set)

42. Parametrické datové typy • Nové typy • obohacováním původních o druhy a operace • často stejné, jen nad jinými základy • liší se jen některými prvky => parametrický datový typ odlišné prvky - parametry

43. Množina typ: MNOŽINA( ELEMENT ) parametr: typ prvků ELEMENT požadavky na parametr: druhy: Elem operace: eq(_,_): Elem, Elem-> Bool použité typy: ELEMENT, přirozená čísla, logické hodnoty druhy: Elem, Bool, Set, Nat

44. Množina operace: []: Set (prázdná množina) ins(_,_): Elem,Set ->Set (vložení prvku) del(_,_): Elem,Set ->Set (zrušení -“- ) in(_,_) : Elem,Set ->Bool(test přísluš.) card(_) : Set->Nat (počet prvků)

45. Množina bez opakování proměnné: s: Set, x,y: Elem axiomy: ins(x,s) = if in(x,s) then s del(x,[])=[] del(x,ins(y,s))= if eq(x,y) then del(x,s) else ins(y,del(x,s)) bez opakování prvků nezáleží na pořadí vkládání

46. Množina bez opakování axiomy: (pokračování) in(x,[]) = false in(x,ins(y,s))= if eq(x,y)then true else in(x,s) card([]) = 0 card(ins(x,s)) = if(in(x,s)) card(s) else succ(card(s))

47. Množina bez opakování axiomy: (pokračování) eq([],[]) = true eq([], ins(x, t)) = false eq(s,t) = eq(t,s) eq(ins(x,s),t) = if in(x,s) then eq(s,t) else if in(x,t) then eq(s,del(x,t)) else false bez opakování prvků

48. Abstraktní datové typy • Fronta (Queue) • Zásobník (Stack) • Pole (Array) • Tabulka (Table) • Seznam (List) • Strom (Tree) • Množina (Set)

49. Appendix A Bool example

50. true,false Bool and,eq not Bool data type - signature • Logical value - Bool • Diagram: Symbolic: see next slide