Lösningsförslag till tentamen Datastrukturer, DAT037,

Relevanta dokument
Lösningsförslag till tentamen Datastrukturer, DAT037,

Lösningsförslag till tentamen Datastrukturer, DAT037 (DAT036), Tiden det tar att utföra en iteration av loopen är oberoende av värdet på

Tentamen Datastrukturer (DAT036)

Föreläsning Datastrukturer (DAT036)

Föreläsning 10 Datastrukturer (DAT037)

Lösningsförslag för tentamen i Datastrukturer (DAT037) från

Föreläsning 9 Datastrukturer (DAT037)

Tentamen Datastrukturer, DAT037 (DAT036)

Tentamen Datastrukturer (DAT037)

Tentamen Datastrukturer, DAT037 (DAT036)

Föreläsning 7. Träd och binära sökträd

Föreläsning 7. Träd och binära sökträd

Lösningsförslag för tentamen i Datastrukturer (DAT036) från

Tentamen Datastrukturer (DAT036)

Lösningsförslag till exempeltenta 1

Föreläsning 7 Innehåll. Rekursion. Rekursiv problemlösning. Rekursiv problemlösning Mönster för rekursiv algoritm. Rekursion. Rekursivt tänkande:

Datastrukturer, algoritmer och programkonstruktion (DVA104, VT 2015) Föreläsning 6

Tentamen Programmeringsteknik II Inledning. Anmälningskod:

Tentamen Datastrukturer (DAT036)

Föreläsning 2 Datastrukturer (DAT037)

Anmälningskod: Lägg uppgifterna i ordning. Skriv uppgiftsnummer (gäller B-delen) och din kod överst i högra hörnet på alla papper

Föreläsning 2 Datastrukturer (DAT037)

if (n==null) { return null; } else { return new Node(n.data, copy(n.next));

Tentamen Datastrukturer (DAT036)

Föreläsning 4 Datastrukturer (DAT037)

Föreläsning 9 Innehåll

Dugga Datastrukturer (DAT036)

Föreläsning 5 Datastrukturer (DAT037)

Föreläsning 10 Innehåll. Prioritetsköer och heapar. ADT Prioritetskö. Interface för Prioritetskö. Exempel på vad du ska kunna

Föreläsning 5 Innehåll

Tentamen Datastrukturer (DAT036/DAT037/DIT960)

Föreläsning 4 Innehåll. Abstrakta datatypen lista. Implementering av listor. Abstrakt datatypen lista. Abstrakt datatyp

Tentamen Programmeringsteknik II och NV2 (alla varianter) Skriv bara på framsidan av varje papper.

Föreläsning 5 Innehåll. Val av algoritm och datastruktur. Analys av algoritmer. Tidsåtgång och problemets storlek

Klassen BST som definierar binära sökträd med tal som nycklar och enda data. Varje nyckel är unik dvs förekommer endast en

Föreläsning Datastrukturer (DAT036)

Föreläsning Datastrukturer (DAT036)

Den som bara har en hammare tror att alla problem är spikar

TDDC30. Objektorienterad programmering i Java, datastrukturer och algoritmer. Föreläsning 8 Erik Nilsson, Institutionen för Datavetenskap, LiU

Föreläsning Datastrukturer (DAT037)

Algoritmer och effektivitet. Föreläsning 5 Innehåll. Analys av algoritmer. Analys av algoritmer Tidskomplexitet. Algoritmer och effektivitet

Lägg uppgifterna i ordning. Skriv uppgiftsnummer och din kod överst i högra hörnet på alla papper.

Tentamen, EDA690 Algoritmer och Datastrukturer, Helsingborg

Lösningsförslag till tentamen i EDA690 Algoritmer och Datastrukturer, Helsingborg

Upplägg. Binära träd. Träd. Binära träd. Binära träd. Antal löv på ett träd. Binära träd (9) Binära sökträd (10.1)

DAI2 (TIDAL) + I2 (TKIEK)

Tentamen Programmeringsteknik II Skrivtid: Hjälpmedel: Java-bok (vilken som helst) Skriv läsligt! Använd inte rödpenna!

Föreläsning 3 Datastrukturer (DAT037)

Tentamen, Algoritmer och datastrukturer

Länkade strukturer, parametriserade typer och undantag

Självbalanserande AVL-träd Weiss, avsnitt 4.4

Tentamen i Algoritmer & Datastrukturer i Java

Lägg uppgifterna i ordning. Skriv uppgiftsnummer och din kod överst i högra hörnet på alla papper.

Lösningsförslag. Programmeringsmetodik, KV: Java och OOP. 17 januari 2004

Datastrukturer. föreläsning 3. Stacks 1

Föreläsning Datastrukturer (DAT036)

ADT Prioritetskö. Föreläsning 13 Innehåll. Prioritetskö vs FIFO-kö. Prioritetskö Exempel på användning. Prioritetsköer och heapar

Trädstrukturer och grafer

TENTAMEN: Algoritmer och datastrukturer. Läs detta!

Lösningsförslag till tentamen i EDAA01 programmeringsteknik fördjupningkurs

Sökning och sortering

TDDC30. Objektorienterad programmering i Java, datastrukturer och algoritmer. Föreläsning 9 Jonas Lindgren, Institutionen för Datavetenskap, LiU

Det är principer och idéer som är viktiga. Skriv så att du övertygar rättaren om att du har förstått dessa även om detaljer kan vara felaktiga.

Algoritmer och datastrukturer

Tentamen i Algoritmer & Datastrukturer i Java

Föreläsning 4 Innehåll

Binära sökträd. Seminarium 9 Binära sökträd Innehåll. Traversering av binära sökträd. Binära sökträd Definition. Exempel på vad du ska kunna

13 Prioritetsköer, heapar

Föreläsning 2. Länkad lista och iterator

Exempeltenta GruDat 2002/2003

Tentamen Programmeringsteknik 2 och MN Skrivtid: Inga hjälpmedel.

Seminarium 13 Innehåll

public static void mystery(int n) { if (n > 0){ mystery(n-1); System.out.print(n * 4); mystery(n-1); } }

F5: Debriefing OU2, repetition av listor, träd och hashtabeller. Carl Nettelblad

Tentamen Datastrukturer D DAT 036/DIT960

TDDI16 Datastrukturer och algoritmer. Algoritmanalys

Lösningar Datastrukturer TDA

Föreläsning 8 Datastrukturer (DAT037)

Föreläsning 4 Datastrukturer (DAT037)

ADT Prioritetskö. Föreläsning 12 Innehåll. Prioritetskö. Interface för Prioritetskö. Prioritetsköer och heapar

Fredag 10 juni 2016 kl 8 12

Föreläsning 10 Innehåll

Det är principer och idéer som är viktiga. Skriv så att du övertygar rättaren att du har förstått dessa även om detaljer kan vara felaktiga.

Föreläsning 11 Innehåll. Diskutera. Binära sökträd Definition. Inordertraversering av binära sökträd

Tentamen'('Datastrukturer,'algoritmer'och'programkonstruktion.'

Självbalanserande träd AVL-träd. Koffman & Wolfgang kapitel 9, avsnitt 1 2

Programmering för språkteknologer II, HT2014. Rum

public boolean containskey(string key) { return search(key, head)!= null; }

Tentamen Datastrukturer D DAT 035/INN960

Föreläsning 10 Innehåll. Diskutera. Inordertraversering av binära sökträd. Binära sökträd Definition

Föreläsning 13 Datastrukturer (DAT037)

Föreläsning 13 Datastrukturer (DAT037)

Tentamen Datastrukturer (DAT036)

Listor. Koffman & Wolfgang kapitel 2, avsnitt , och 2.9

Tentamen i Algoritmer & Datastrukturer i Java

Saker du ska kunna Föreläsning 13 & 14

Föreläsning 2. Länkad lista och iterator

F11 - Rekursion. ID1004 Objektorienterad programmering Fredrik Kilander

Tentamen med lösningsförslag Datastrukturer för D2 DAT 035

Transkript:

Lösningsförslag till tentamen Datastrukturer, DAT037, 2018-01-10 1. Båda looparna upprepas n gånger. s.pop() tar O(1), eventuellt amorterat. t.add() tar O(log i) för i:te iterationen av första loopen. t.deletemax() tar O(log(n i)) för i:te iterationen av andra loopen. l.addfirst() tar O(1). Övrigt tar konstant tid. Tidskomplexiteten är O( n i=1 (1 + log i) + n i=1 (log(n i) + 1)) = O(n log n + n log n) = O(n log n) 2. 5 8 8 10 14 13 16 12 13 15 20 20 1

3. Uppgiften säger inte vad higher(x) ska returnera om det inte finns tal större än x men x själv finns i mängden. Lösningen får därför returnera vad som helst i detta fall. I förslaget nedan returneras null. För betyg tre kan man t.ex. lagra heltalen sorterat i en lista. add() tar då O(n), higher() tar O(log n) med binärsökning och longestinterval() tar O(n) med linjärsökning efter längsta intervall mellan två efterföljande tal. För högre betyg kan man använda två balanserade sökträd, ett med heltal och ett med intervall sorterade på längd. För intervallen kan man ha en hjälpklass och en komparator definierad för denna. Denna komparator tittar på intervallens längd i första hand och på t.ex. vänstergränsen i andra hand. class IntSet { private class Interval { int leftlimit, rightlimit; Interval(int leftlimit, int rightlimit) { this.leftlimit = leftlimit; this.rightlimit = rightlimit; private class IntervalComparator implements Comparator<Interval> { @Override public int compare(interval o1, Interval o2) { int lengthdiff = (o2.rightlimit - o2.leftlimit) - (o1.rightlimit - o1.leftlimit); if (lengthdiff == 0) return o1.leftlimit - o2.leftlimit; return lengthdiff; private TreeSet<Integer> s = new TreeSet<>(); private TreeSet<Interval> intervals = new TreeSet<>(new IntervalComparator()); public void add(int x) { if (s.contains(x)) return; s.add(x); Integer prev = s.lower(x); Integer next = s.higher(x); if (prev!= null && next!= null) { intervals.remove(new Interval(prev, next)); 2

if (prev!= null) { intervals.add(new Interval(prev, x)); if (next!= null) { intervals.add(new Interval(x, next)); public Integer higher(int x) { return s.higher(x); public Integer longestinterval() { if (intervals.isempty()) return null; return intervals.first().leftlimit; lower() och higher() är definierade i Java collections framework så de får räknas som standardoperationer. lower()/higher() utför en vanlig sökning och när den når värdet eller ett tomt delträd returnerar den närmaste förfader för vilken noden eller det tomma delträdet befinner sig i höger/vänster delträd. Dessa operationer har logaritmisk komplexitet. first() är också definierad i Java collections framework så den får räknas som en standardoperation. Denna traverserar trädet genom att hela tiden gå till vänster. Denna operation har logaritmisk tidskomplexitet. s innehåller n element och intervals innehåller n 1 stycken. Trädoperationerna tar alltså O(log n). Konstruktorn/empty() tar O(1). add() innehåller inga loopar och alla operationer tar max O(log n). longestinterval() innehåller också operationer som tar max O(log n). 3

4. För trea kan man göra en dfs som inte håller reda på om en nod redan besökts och räkna antal vägar man kommer till slutnoden. För högre betyg kan man göra en dfs som för varje nod håller reda på om den är besökt och, om den är besökt, hur många väger det finns från denna nod till slutnoden. public int countpaths(int start, int dest) { int[] viscount = new int[adj.length]; for (int i = 0; i < viscount.length; i++) { viscount[i] = -1; viscount[dest] = 1; dfs(viscount, start); return viscount[start]; private void dfs(int[] viscount, int cur) { if (viscount[cur] >= 0) return; int n = 0; for (int i = 0; i < adj[cur].length; i++) { dfs(viscount, adj[cur][i]); n += viscount[adj[cur][i]]; viscount[cur] = n; Talet -1 i viscount representerar att noden inte besökts/antalet vägar till slutnoden är okänt. Loopen i countpaths tar O(v). Hjälpmetoden dfs anropas max e + 1 gånger därför att rekursiva anrop sker max en gång per kant eftersom loopen i dfs bara utgörs max en gång per nod eftersom if-satsen på första raden avslutar metoden om noden redan besökts. viscount[cur] sätts inte förrän i slutet av metoden men detta gör inget eftersom grafen är acyklisk vilket innebär att noden cur inte kommer besökas i de rekursiva anropen. Koden efter första raden i dfs utförs max v gånger och loopen itereras som sagt totalt e gånger. Tidskomplexiteten är alltså O(v + e). 4

5. public boolean contains(a e) { Node c = first; while (c!= null) { if (c.contents.equals(e)) return true; c = c.next; return false; public void reverse() { Node c = first; Node p = null; while (c!= null) { Node n = c.next; c.next = p; p = c; c = n; first = p; Loopen i contains upprepas i värsta fall n gånger. Varje iteration samt övrig kod tar konstant tid. Alltså O(n). Loopen i reverse upprepas n gånger. Varje iteration samt övrig kod tar konstant tid. Alltså O(n). 5

6. För trea kan man använda en länkad lista av strängar. add lägger till element till listan. Det tar O(1). contains gör linjärsökning. För varje element i listan tar jämförelsen O(l) i värsta fall. Totalt tar det O(ln). restricttoprefix går igenom alla element och tar bort alla som inte börjar på s. Det tar O(ln). För högre betyg kan man använda ett prefixträd. Varje nod har tio barn, ett för varje siffra. add och contains utförs som standardoperationerna för prefixträd. Dessa tar O(l). restricttoprefix utför en sökning efter s och på vägen raderas alla delträd förutom det barn man går vidare till. class Set { private class Node { boolean member = false; Node[] children = new Node[10]; private Node root = null; public Set() { public void add(string s) {... public boolean contains(string s) {... public void restricttoprefix(string s) { Node n = root; int i = 0; while (n!= null && i < s.length()) { int d = Character.digit(s.charAt(i), 10); for (int j = 0; j < 10; j++) { if (j!= d) n.children[j] = null; n.member = false; n = n.children[d]; i++; if (n == null) { root = null; Loopen i restricttoprefix upprepas max l gånger. Den inre loopen upprepas ett konstant antal gånger. If-satsen på slutet och alla atomära satser tar konstant tid. Alltså är tidskomplexiteten O(l). 6