1 Fundamentale datastrukturer

2 Definitioner: abstrakt datatype, datastruktur Elementære datastrukturer og abstrakte datatyper : arrays, stakke, køer, hægtede lister, træer, hashtabeller, prioritetskøer Plan

3 Definitioner En type er en samling af værdier. Eks. int betegner i Java den type, der udgøres af heltallene fra til En abstrakt datatype er en datatype, der udelukkende er specificeret ved hjælp af typen og de tilknyttede operationer. Kun operationernes input/output-relationer er specificeret - ikke deres konkrete realisering. Hverken datarepræsentation eller algoritmer må medtages i specifikationen. En abstrakt datatype specificerer “hvad”, men ikke “hvordan”. En datatype er en type tilknyttet en mængde af operationer på typen. Eks. int er en datatype. Addition er et eksempel på en tilknyttet operation.

4 Abstrakte datatyper En ADT skjuler den konkrete implementation fra anvenderen (klienten). Fordele: (1) Det er lettere at bruge noget, hvis det ikke kræver internt kendskab til virkemåden. Tænk f.eks. på en radio eller en vaskemaskine (2) Den konkrete implementation kan ændres, uden at klienten behøver at få det at vide. Realisering i Java: En ADT kan realiseres som en klasse, hvor data er private. Brug“ get ters” (accessors) and “ set ters” (mutators) til henholdsvis at tilgå og ændre data.

5 En datastruktur er en samling variable, muligvis af forskellig type, der er indbyrdes forbundet på en eller anden måde. Realisering i Java: ved simple variable, arrays og klasseobjekter Datastruktur

6 (1) Datastruktur: Et array er en sammenhængende blok af lagerceller, hvor hver lagercelle indeholder et dataelement af en fast længde. Arrays (to perspektiver) celle array

7 (2) Abstrakt datatype: Et array er en samling af dataelementer af samme type, hvor hvert dataelement kan identificeres med et heltal, kaldet indeks. Med dette perspektiv kan et array implementeres på mange måder.

8 Datastrukturen array Realisering i Java: Oprettelse: int a[] = new int[100]; eller int[] a = new int[100]; opretter et array med 100 elementer af typen int : a[0], a[1],..., a[99] Tilgang til et element: a[27] Aflæsning af arrayets længde: a.length (= 100)

9 Vigtig egenskab Tilgangstiden til ethvert element er konstant. a[0] a[1] a[2] a[3] a[4] a[5] a[6] 0: 1: 2: 3: 4: 5: 6: adresse( a[i] ) = adresse( a[0] ) + i *længde(type) adresse( a[0] )

10 Eratosthenes si (cirka 200 f. Kr.) Et primtal er et positivt heltal ≥ 2, som ikke er deleligt med andre tal end 1 og sig selv, f.eks. 2, 3, 5, 7, 11. Ide til algoritme: Opret et boolean array isPrime med alle elementer sat til true. Gennemløb herefter alle tal mellem 2 og N, som er produktet af to tal (begge > 1), og sæt isPrime til false for disse. Til sidst udskrives de tal, i, hvor isPrime[i] stadig er true. Problem: udskriv alle primtal ≤ N 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50

11 public class Eratosthenes {final static int N = ; public static void main(String args[]) { boolean isPrime[] = new boolean[N+1]; int i, j; for (i = 2; i <= N; i++) isPrime[i] = true; for (i = 2; i <= N/2; i++) for (j = 2; j <= N/i; j++) IsPrime[i*j] = false; for (i = 2; i <= N; i++) if (IsPrime[i]) System.out.print(i + " "); System.out.println();} } Vi skal gennemløbe alle tal i*j, hvor i ≥ 2, j ≥ 2 og i*j ≤ N. Hvis j ≥ 2 og i*j ≤ N, så må i ≤ N/2. Hvis i*j ≤ N, så må j ≤ N/i. Vanskeligheden ligger i gennemløbet.

12 Koden kan effektiviseres ved at indsætte testen if (isPrime[i]) før j -løkken. Hvorfor? I j -løkkens initialiseringsdel kan j = 2 erstattes med j = i. Hvorfor? I i -løkkens betingelsesdel kan i <= N/2 erstattes med i*i <= N. Hvorfor? for (i = 2; i <= N/2; i++) for (j = 2; j <= N/i; j++) IsPrime[i*j] = false; Effektivisering for (i = 2; i*i <= N; i++) if (isPrime[i]) for (j = i; j <= N/i; j++) IsPrime[i*j] = false;

13 Version 1: for (i = 2; i <= N/2; i++) for (j = 2; j <= N/i; j++) IsPrime[i*j] = false; Version 2: for (i = 2; i <= N/2; i++) if (isPrime[i]) for (j = 2; j <= N/i; j++) IsPrime[i*j] = false; Version 3: for (i = 2; i <= N/2; i++) if (isPrime[i]) for (j = i; j <= N/i; j++) IsPrime[i*j] = false; Version 4: for (i = 2; i*i <= N; i++) if (isPrime[i]) for (j = i; j <= N/i; j++) IsPrime[i*j] = false; Version 5: for (i = 2; i*i <= N; i++) if (isPrime[i]) for (p = i*i; p <= N; p += i) IsPrime[p] = false; Måling af programeffektivitet Version j / p -iterationer Tid (sek) 1 1,657,511, ,275, ,570, ,570, ,570, N = 100,000,000 Mac G3, 233 MHz

14 Måling af tidsforbrug i Java double startTime = System.currentTimeMillis(); Kode System.out.println("Time: " + (System.currentTimeMillis() - startTime)/ "seconds");

15 for (i = 2; i <= N/2; i++) for (j = 2; j <= N/i; j++) IsPrime[i*j] = false; Kompleksiteten af Eratosthenes si Hvor mange gange udføres sætningen i den indre løkke? Da vi blot er interesseret i en øvre grænse (O-notation), udføres beregningerne i stedet på programstumpen: for (i = 1; i <= N; i++) for (j = 1; j <= N/i; j++) IsPrime[i*j] = false; Svar: N/1 + N/2 + N/ N/N = N(1 + 1/2 + 1/ /N) = NH N = N(lnN ) = O(N logN) Se side 126 i lærebogen

16 for (i = 1; i <= N; i++) if (isPrime[i]) for (j = 1; j <= N/i; j++) IsPrime[i*j] = false; Hvor mange gange udføres sætningen i den indre løkke? For antallet af primtal mindre end eller lig med N, P(N), gælder, at P(N)/N nærmer sig 1/ln N, når N vokser Kompleksiteten af den optimerede udgave Sandsynligheden for at påbegynde den indre løkke er 1/lnN. Kompleksiteten er derfor O(N log N/ln N) = O(N).

17 Empirisk undersøgelse af den optimerede udgave

18 Realisering i Java: Oprettelse: int a[][] = new int[5][4]; opretter et array med 5*4 = 20 heltallige elementer: a[0][0] a[0][1] a[0][2] a[0][3] a[1][0] a[1][1] a[1][2] a[1][3] a[2][0] a[2][1] a[2][2] a[2][3] a[3][0] a[3][1] a[3][2] a[3][3] a[4][0] a[4][1] a[4][2] a[4][3] 2-dimensionale arrays Tilgang til et element: a[3][2] Aflæsning af antal rækker: a.length (= 5) Aflæsning af antal søjler: a[0].length (= 4)

19 En hægtet liste er en mængde at dataelementer, der er organiseret sekventielt, således at hvert element (kaldet en knude) indeholder en peger (kaldet en hægte) til det næste element. Hægtede lister Bemærk: enhver knude indeholder en hægte, også listens sidste. A L I S T ALI S T first

20 Operationer på hægtede lister Tidsforbrug: Konstant. Kun 2 hægter skal ændres (uafhængigt af listens længde) Tidsforbrug: Konstant. Kun 1 hægte skal ændres (uafhængigt af listens længde) (1) Indsættelse (2) Sletning X A L I S T first A L I S T X

21 Implementering af hægtede lister i Java class ListNode { Object data; ListNode next; }

22 Gennemløb af hægtet liste ListNode current = firstListNode; while (current != null) { process(current.data); current = current.next; } for (ListNode current = firstListNode; current != null; current = current.next) process(current.data); eller

23 class ListNode { ListNode next; Object data; public void insertAfter(ListNode t) { next = t.next; t.next = this; } public void deleteAfter(ListNode t) { t.next = next; } Implementering af indsættelse og sletning t t.next this

24 En hægtet liste kan også opfattes som en abstrakt datatype public interface List { boolean isEmpty(); void makeEmpty(); } package DataStructures; import Exceptions.*; Listens elementer tilgås ved hjælp af en iterator.

25 Ved at tilgå en datastrukturs elementer igennem en iterator opnås: (1) dataabstraktion (2) sikkerhed mod forkert brug Den underliggende repræsentation afsløres ikke. Iterator - et designmønster - Iterator current position Object ListNode

26 En iterator for hægtede lister public interface ListItr { void insert(Object x) throws ItemNotFound; void remove(Object x) throws ItemNotFound; boolean find(Object x); void zeroth(); void first(); void advance(); boolean isInList(); Object retrieve(); } ListItr itr = new LinkedListItr(theList);for (itr.first(); itr.isInList(); itr.advance()) System.out.println(itr.retrieve());

27 Et simpelt testprogram import DataStructures.*; import Exceptions.*; public class TestList { public static void main(String[] args) { List theList = new LinkedList(); ListItr itr = new LinkedListItr(theList); for (int i = 0; i < 5; i++) { try { itr.insert(new Integer(i)); } catch (ItemNotFound e) {} // Cannot happen itr.zeroth(); // Reset itr to the start } for (itr.first(); itr.isInList(); itr.advance()) System.out.print(" " + itr.retrieve()); System.out.println(" end"); }

28 Dobbelthægtede lister Problemer med enkelthægtede lister: En knude kan ikke fjernes effektivt fra en liste, med mindre forgængerknuden er kendt. Listen kan kun gennemløbes i én retning. Løses med en dobbelthægtet liste. I det følgende præsenteres en Java-pakke til håndtering af tovejslister. Pakken svarer helt til Simulas indbyggede pakke SIMSET. A L I S T

29 Klasserne Link og Head fra en klients synspunkt Head: Listehovedet Link: Et listeelement first() last() suc() null suc() pred() Head Link

30 public class Link { public Link pred(); public Link suc(); public void out(); public void into(Head h); public void follow(Link_eller_Head p); public void precede(Link_eller_Head p); } Pakken simset package simset; public class Head { public Link first(); public Link last(); public boolean empty(); public int cardinal(); public void clear(); }

31 Arrays og hægtede lister (pro et contra) Visse operationer er mere effektive for en liste end for et array, f.eks. indsættelse og sletning (flytning undgås). Men visse operationer er mere effektive for et array, f.eks. bestemmelse af det k´te element. En array-repræsentation fylder mindre (der spares plads til hægterne).

32 En stak (LIFO = LastInFirstOut) En stak er en sekvens af dataelementer af samme type, som muliggør følgende to operationer: push(x): Læg dataelementet x øverst på stakken pop: Fjern det øverste element på stakken Stak poppush Kun stakkens øverste element ( top ) er tilgængeligt

33 En stak er en abstrakt datatype public interface Stack { void push(Object x); void pop() throws Underflow; Object top() throws Underflow; Object topAndPop() throws Underflow; boolean isEmpty(); void makeEmpty(); } package DataStructures; import Exceptions.*;

34 Et simpelt testprogram import DataStructures.*; import Exceptions.*; public class TestStack { public static void main(String[] args) { Stack s = new StackAr(); for(int i = 0; i < 5; i++) s.push(new Integer(i)); try { for (;;) System.out.print(" " + s.topAndPop()); } catch (Underflow e) {} System.out.println(); }

35 Anvendelser af en stak En stak kan bl.a. bruges til at vende om på en given rækkefølge (at gøre noget baglæns) at gemme mellemresultater f.eks. ved beregning af udtrykket 3*4 + 5*6 +7 at behandle parentetiske strukturer f.eks. ved kontrol af, om parenteserne stemmer i sekvensen { [ ( { } ( ) ] ) }

36 En kø (FIFO = FirstInFirstOut) En kø er en sekvens af dataelementer af samme type, som muliggør følgende to operationer: enqueue(x): Sæt dataelementet x bagest i køen dequeue: Fjern det forreste element fra køen dequeue enqueue Kø

37 En kø er en abstrakt datatype public interface Queue { void enqueue(Object x); Object dequeue() throws Underflow; Object getFront() throws Underflow; boolean isEmpty(); void makeEmpty(); } package DataStructures; import Exceptions.*;

38 Et simpelt testprogram import DataStructures.*; import Exceptions.*; public class TestQueue { public static void main(String[] args) { Queue q = new QueueAr(); for(int i = 0; i < 5; i++) q.enqueue(new Integer(i)); try { for (;;) System.out.print(" " + q.dequeue()); } catch(Underflow e) {} System.out.println(); }

39 Java-klassen Vector (en klasse til håndtering af dynamiske tabeller) class Vector { Object elementAt(int index); void setElementAt(Object obj, int index); void insertElementAt(Object obj, int index); void removeElementAt(int index); void addElement(Object obj); void removeElement(Object obj); boolean contains(Object obj); boolean isEmpty(); int size(); int indexOf(Object obj); Object firstElement(); Object lastElement(); }

40 Java-klassen Stack (implementeret ved hjælp af class Vector) class Stack extends Vector { Object push(Object obj) { addElement(obj); return obj; } Object pop() { Object obj = peek(); removeElementAt(size() - 1); return obj; } Object peek() { int len = size(); if (len == 0) throw new EmptyStackException(); return elementAt(len - 1); } boolean empty() { return size() == 0; } }

41 Et træ er en samling af knuder og kanter, (V, E), som opfylder visse krav: En knude, v, er et simpelt dataobjekt, der kan have et navn og en tilknyttet information. En af knuderne er udpeget som rod i træet. En kant, (v 1,v 2 ), er en forbindelse imellem to knuder, v 1 og v 2. En vej er en liste af knuder, (v 1,v 2,...,v k ), hvor alle successive knuder, v i og v i+1, er indbyrdes forbundne (dvs. tilhører E). For at udgøre et træ skal der mellem roden og enhver anden knude findes præcis én vej. Træer

42 Terminologi Rod: R X er far til Y Y er søn til X (Y er barn af X) U, V og W er børn af T S er bedstefar til Z S er forgænger til Y (S er over Y) Y er efterkommer af S (Y er under S) Blade: Y, Z, U, V, W Indre knuder : R, S, X, T Rod R S X Y Z T U VW Blad Indre knude Niveau 0 Niveau 1 Niveau 2 Niveau 3

43 Eksempel på anvendelse af træer (et filsystem ) Et filsystem kan beskrives ved et træ: Knuderne repræsenterer kataloger og filer. Træets blade indeholder filer (eller tomme kataloger).

44 Terminologi (fortsat) En knudes niveau er antallet af knuder på vejen fra knuden til roden (minus knuden selv). Et træs højde er det maksimale niveau for alle knuder i træet.

45 Terminologi (fortsat) Enhver knude i et træ er rod for et undertræ bestående af knuden selv og alle knuder under den. Et træ kaldes ordnet, hvis rækkefølgen af sønnerne for enhver knude er specificeret. En mængde af træer kaldes en skov.

46 Et træ er sammenhængende, dvs. der er en vej fra enhver knude til enhver anden knude. Et træ har ingen cykler, dvs. enhver vej indeholder en knude højst én gang. Nyttig definition: Et tomt træ er et træ uden kanter og knuder. Egenskaber ved træer

47 Binære træer Rekursiv definition: Et binært træ er enten et tomt træ, eller en knude, som har et venstre og et højre binært undertræ. Et binært træ er et ordnet træ, hvor hver knude har højst 2 sønner.

48 Eksempel på et binært træ P’s venstre søn er M P’s højre søn er L P M S A A L E R E E T

49 class BinaryNode { Object data; BinaryNode left, right; } Repræsentation af binære træer En null -reference angiver et tomt (under)træ

50 * A + F * * E D + BC Træ for udtrykket A * ( ( ( B + C ) * ( D * E ) ) + F) Eksempel på anvendelse af binære træer (et udtrykstræ ) operator (i indre knude) operand (i blad)

51 Repræsentation af generelle træer (1) (1) Far-referencer class Node { Node dad; }

52 Repræsentation af generelle træer (2) (2) Binært træ class Node { Node firstSon, brother; } firstSon brother

53 Binære søgetræer (muliggør søgning i logaritmisk tid) public interface SearchTree { void insert(Comparable x) throws DuplicateItem; void remove(Comparable x) throws ItemNotFound; void removeMin() throws ItemNotFound; Comparable findMin() throws ItemNotFound; Comparable findMax() throws ItemNotFound; Comparable find(Comparable x) throws ItemNotFound; boolean isEmpty(); void makeEmpty(); void printTree(); }

54 class MyString public final class MyString implements Comparable, Hashable { private String value; public MyString(String x) { value = x; } public String toString() { return value; } public int compares(Comparable rhs) { return value.compareTo(((MyString) rhs).value); } public boolean lessThan(Comparable rhs) { return compares(rhs) < 0; } public boolean equals(Object rhs) { return value.equals(((MyString) rhs).value); } public int hash(int tableSize) { return DataStructures.QuadraticProbingTable. hash(value, tableSize); } }

55 Et simpelt testprogram public class TestSearchTree { public static void main(String[] args) { SearchTree t = new BinarySearchTree(); try { t.insert(new MyString("Becky")); } catch(DuplicateItem e) {} // Cannot happen MyString result = null; try { result = (MyString) t.find(new MyString("Becky")); System.out.print("Found " + result + ";"); } catch(ItemNotFound e) { System.out.print("Becky not found;");} try { result = (MyString) t.find(new MyString("Mark")); System.out.print(" Found " + result + "; "); } catch(ItemNotFound e) { System.out.print(" Mark not found;" ); } }

56 Hashtabeller (muliggør søgning i konstant tid) public interface HashTable { void insert(Hashable x); void remove(Hashable x) throws ItemNotFound; Hashable find(Hashable x) throws ItemNotFound; boolean isEmpty(); void makeEmpty(); } public interface Hashable { int hash(int tableSize); }

57 Et simpelt testprogram public final class TestHashTable { public static void main(String[] args) { HashTable h = new QuadraticProbingTable(); h.insert(new MyString("Becky")); MyString result = null; try { result = (MyString) h.find(new MyString("Becky")); System.out.println("Found " + result); } catch(ItemNotFound e) { System.out.println("Becky not found"); } }

58 Prioritetskøer (muliggør behandling af elementer i prioriteret rækkefølge) public interface PriorityQueue { void insert(Comparable x); void deleteMin() throws Underflow; Comparable findMin() throws Underflow; boolean isEmpty(); void makeEmpty(); }

59 Et simpelt testprogram public final class TestPriorityQueue { public static void main(String[] args) { PriorityQueue pq = new PairHeap(); pq.insert(new MyInteger(4)); pq.insert(new MyInteger(2)); pq.insert(new MyInteger(1)); pq.insert(new MyInteger(3)); pq.insert(new MyInteger(0)); try { for (;;) System.out.print(" " + pq.deleteMin()); } catch(Underflow e) {} }

60 Sammenfatning af datastrukturerne

61 Ugeseddel september september Læs kapitel 7 i lærebogen (side ) Løs følgende opgaver 2-1. Opgave Opgave Opgave Opgave Opgave Opgave 6.14