Datastrukturer. föreläsning 3. Stacks 1

Transkript

1 Datastrukturer föreläsning 3 Stacks 1

2 Abstrakta datatyper Stackar - stacks Köer - queues Dubbeländade köer - deques Vektorer vectors (array lists) All är listor men ger tillgång till olika operationer Stacks 2

3 Stackar

4 Gränssnitt för stackar i Java 5 public interface Stack<E>{ public void push(e element); public E top() throws EmptyStackException; public E pop() throws EmptyStackException; public boolean isempty(); } public int size(); Stacks 4

5 Exempel på stackar Stackar förekommer överallt i datorvärlden! T ex i Hårdvarustackar! (Se bild) Virtuella maskiner Uttrycksberäkning Syntaxanalys

6 Hur implementera stackar i Java? Stacks 6

7 Hur implementera stackar i Java? Fält? Problem med overflow. Dynamiskt fält, dvs fält som man kan utvidga vid behov? Länkad lista? Enkellänkad? Dubbellänkad? Med eller utan vaktposter? Stacks 7

8 Stack implementerad med fält En variabel size anger storleken på stacken Insättning görs i S[size] Sätt in nytt element här S size Stacks 8

9 Borttagning pop i pseudokod array S integer size tillståndsvariabler Algorithm size() return size Algorithm pop() if isempty() then throw EmptyStackException else size size - 1 return S[size] Stacks 9

10 Nackdelar Fältets storlek är bestämd på förhand och kan inte ändras Fältet kan bli fullt om vi gör många push. Vi får overflow. Om stacken har få element och fältet har många celler använder vi onödigt mycket minne. Stacks 10

11 Dynamiskt fält När fältet blir fullt, skapa ett nytt större fält och kopiera: ( push(o Algorithm if size = V.length then A new array of size for i 0 to size-1 do A[i] V[i] V A V[size] o size size + 1 Stacks 11

12 Hur stort ska det nyallokerade fältet vara? Tidskomplexitet för push? Bästa, värsta, medelfallet? O-komplexitet. Stacks 12

13 Utökning av dynamiska fält Hur stort bör det nya utökade fältet A vara? utöka med fix storlek? dubblera storleken? Tidskomplexitet för insättning? - värsta fallet är O(N), om storleken på fältet är N, både vid utökning med fix storlek och vid dubblering! Varför? Stacks 13

14 Amorterad tidskomplexitet Beräknar exekveringstiden T(n) för n operationer i följd inte bara en operation! Beräkna medeltalet (T(n)/n)! Jmfr tidskomplexitet i medeltal och amorterad tidskomplexitet, vad är skillnaden? Stacks 14

15 Amorterad tidskomplexitet för insättning i dynamiska fält Vi jämför den amorterade tidskomplexiteten för de två metoderna att utöka dynamiska fält (fix utökning och dubblering)! Dvs vi beräknar tiden de tar att utföra n insättningar i båda fallen. Vi börjar med fält med storlek 0 för enkelhets skull. Stacks 15

16 Utökning med fix storlek c amorterad analys Gör n insättningar. Allokera nytt fält k = n/c gånger. Total tidsåtgång T(n) = n + c + 2c + 3c + 4c + + kc = n + c( k) = n + ck(k + 1)/2 insättningstid Eftersom c är konstant så gäller att T(n) är O(n + k 2 ) dvs T(n) är O(n 2 ) Alltså gäller att T(n)/n är O(n)! kopieringstid Stacks 16

17 Dubblering amorterad analys Vi skapar nytt fält k = log 2 n gånger Tiden T(n) det tar att genom föra n insättningar är proportionell mot n k = n + 2 k = n + 2n -1 = 3n -1 ( O(n T(n) är ( O(1 T(n)/n är Stacks 17

18 Nackdelar med dubblering Om vi hela tiden dubblerar storleken på fältet använder vi mer minne än nödvändigt Tiden det tar att utöka fältet kan bli oacceptabelt stor i realtidstillämpningar. Stacks 18

19 Enkellänkad lista Består av en följd av noder Varje nod lagrar element länk till nästa nod elem next nod A B C D Stacks 19

20 Stack med enkellänkad lista Lagra pekare top till första noden. nodes top elements Stacks 20

21 Klass för noder i Java 5 public class Node<E> { private E element; } private Node<E> next; public Node(E e, Node<E> n) {element = e; next = n;} public E getelement() {return element;} public Node<E> getnext() {return next;} public void setelement(e e) {element = e;} public void setnext(node<e> n) {next = n;} Stacks 21

22 Stack som enkellänkad lista public class NodeStack<E> implements Stack<E> { private Node<E> top; private int size; public NodeStack() {top = null; size = 0;} public int size() {return size;} public boolean isempty() {return top == null;} public E top() throws EmptyStackException { if (isempty()) throw new EmptyStackException( )); return top.getelement(); } // se nästa sida} Stacks 22

23 Stack som enkellänkad lista } public E pop() throws EmptyStackException { if (isempty()) throw new EmptyStackException( ); E temp = top.getelement(); top = top.getnext(); size--; return temp; } public void push(e elem) { Node<E> v = new Node<E>(elem,top); top = v; size++; } Stacks 23

24 Synlighet Vilka metoder kan anropa en viss slags metod (eller tillståndsvariabel)? Private: metoder i samma klass Public: alla metoder Protected: metoder i samma paket och i delklasser Friendly (modifierare utlämnad): metoder i samma paket Stacks 24

25 Köer

26 ADT för köer Insättning och borttagning. FIFO ( First in First Out )-principen Köoperationer i G&T ( enqueue(object () dequeue () front () size () isempty ( Collection-klassen Köoperationer i java.util (delklass till ( o offer(e ( kö poll(), remove() (returnerar null resp exception om tom ( kö peek(), element() (returnerar null resp exception om tom size() ärvd från Collection isempty() ärvd Stacks 26

27 Användning av köer Direkta tillämpningar Väntelistor Kö för delade resurser, t ex skrivare Simuleringar Indirekta tillämpningar Hjälpdatastruktur för många algoritmer Del av mer komplexa datastrukturer Stacks 27

28 Implementering av köer med hjälp av fält Använd fält med storlek N på ett cykliskt sätt Två variabler håller reda på början och slutet av kön f index för början på kön ( cell r index för cellen efter slutet på kön (första lediga Q Q kön har flyttat sig åt höger f r kön har gått runt hörnet r f Stacks 28

29 Insättning i kö - pseudokod ( enqueue(o Algorithm if size = N - 1 then throw FullQueueException else Q[r] o r (r + 1) mod N size = size + 1 Q Q f r r f Stacks 29

30 Borttagning ur kö () dequeue Algorithm if size = 0 then throw EmptyQueueException else o Q[f] f (f + 1) mod N size size 1 return o Q Q f r r f Stacks 30

31 Kö implementerad som dynamiskt fält Om fältet är fullt när vi ska sätta in nytt element, skapar vi nytt större fält Amorterad komplexitet för insättning O(n) om utökning med fix storlek O(1) om dubblering Stacks 31