Fundamentale datastrukturer

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 -2147483648 til 2147483647.

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“getters” (accessors) and “setters” (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)

cellearray

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 = 100000000;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,569 491.0 2 309,275,826 74.2 3 242,570,204 48.2 4 242,570,204 44.7 5 242,570,204 44.7

N = 100,000,000Mac G3, 233 MHz

14

Måling af tidsforbrug i Java

double startTime = System.currentTimeMillis();

Kode

System.out.println("Time: " + (System.currentTimeMillis() - startTime)/1000.0 + "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/3 + ... + N/N =N(1 + 1/2 + 1/3 + .... + 1/N) = NHN = N(lnN + 0.577) = 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

A L I 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

first

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 testprogramimport 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 null

suc() suc()

pred() pred() pred()

Head

LinkLink 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, (v1,v2), er en forbindelse imellem to knuder, v1 og v2.

En vej er en liste af knuder, (v1,v2, ... ,vk), hvor alle successive knuder, vi og vi+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: RX er far til Y Y er søn til X (Y er barn af X)U, V og W er børn af TS er bedstefar til ZS 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

RodR

S

X

Y Z

T

U V W

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 MP’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*

*

ED

+

B C

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; }

firstS

on

brother 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

Datastruktur TilgangStak Kun det seneste element, pop: O(1)Kø Kun det tidligste element, dequeue: O(1)

Hægtet liste Ethvert elementSøgetræ Ethvert element, O(logN)Hashtabel Ethvert element, O(1)Prioritetskø Kun elementet med laveste prioritet,

findMin: O(1), deleteMin: O(log N)

61

Ugeseddel 218. september - 25. september

• Læs kapitel 7 i lærebogen (side 173-221)

• Løs følgende opgaver

2-1. Opgave 6.5.

2-2. Opgave 6.7

2-3. Opgave 6.11

2-4. Opgave 6.12

2-5. Opgave 6.13

2-6. Opgave 6.14