Programmering för språkteknologer II, HT2014. Rum
|
|
|
- Elisabeth Danielsson
- för 5 år sedan
- Visningar:
Transkript
1 Programmering för språkteknologer II, HT2014 Avancerad programmering för språkteknologer, HT2014 Rum
2 Idag - Parametriserade typer - Abstrakt datatyp (ADT) - Listor och länkade strukturer - Komplexitet i länkade strukturer resp. arrayer - Undantag 2
3 Parametriserade typer (Generics) 3
4 Parametriserade typer (Generics) Exempel: ArrayList<String> list = new ArrayList<String>(); ArrayList<Integer> list = new ArrayList<Integer>(); Trevligt att kunna återanvända kod på det här sättet. Kan man skapa sådana här själv? 4
5 Parametriserade typer (Generics) Exempel: ArrayList<String> list = new ArrayList<String>(); ArrayList<Integer> list = new ArrayList<Integer>(); Trevligt att kunna återanvända kod på det här sättet. Kan man skapa sådana här själv? Ja!!! Det kallas för att parametrisera en klass. 5
6 Parametrisering på olika nivåer - Generiskt interface (gränssnitt): ett gränssnitt som kan hantera olika typer - Generisk klass: en klass som kan hantera olika typer - Generisk metod: en metod som kan hantera olika typer 6
7 Parametriserade typer (Generics) - En ArrayList beter sig likadant oavsett vad du lagrar i den - Implementationen är inte beroende av innehållet - Innehållets typ introduceras i en hållare, <...>, Dvs när man skapar en instans av klassen: Exempel: ArrayList<String> tokens = new ArrayList<String>(); ArrayList<Sentence> sentences = new ArrayList<Sentence>(); 7
8 Parametriserad metod - Exempel public append(arraylist<t> from, ArrayList<T> to) { for(t value: from) { to.add(value); Example: //call, assume that ArrayList<String> a and b exist append(a,b); 8
9 Parametriserad klass - Exempel public class MyClass<T> { T somevariable; ArrayList<T> somelistvarialble; public append(arraylist<t> from, ArrayList<T> to) { for(t value: from) { to.add(value); Example: public void foo() { // call, assume that ArrayList<String> a and b exist MyClass<String> c = new MyClass<String>(); c.append(a,b); 9
10 Parametrisering Komplikationer Om vi ger en abstrakt klass eller ett gränssnitt som parameter T? Exempel: ArrayList<MyInterface> list = new ArrayList<MyInterface>(); Problem: - Alla new T(...) blir ogiltiga 10
11 Parametrisering Komplikationer Om vi ger en abstrakt klass eller ett gränssnitt som parameter T? Problem: - Alla new T(...) blir ogiltiga Lösningar: - Använd endast implementerade klasser som parametrar - Skapa aldrig instanser av parametertyper T x = new T(); 11
12 Parametrisering Komplikationer Man kan aldrig göra följande: - Skapa objekt av typen T T x = new T(); - Skapa arrayer av objekt av typen T T[] x = new T[size]; 12
13 Parametrisering Komplikationer Man kan aldrig göra följande: - Skapa objekt av typen T olösligt T x = new T(); - Skapa arrayer av objekt av typen T T[] x = new T[size]; Lösning: T[] array = new (T[]) Object[size]; 13
14 Parametrisering Komplikationer Lösning: T[] array = new (T[]) Object[size]; Problem: - Man får följande varning: MyClass.java uses unchecked or unsafe operations 14
15 Parametrisering Komplikationer Problem: - Man får följande varning: MyClass.java uses unchecked or unsafe operations Lösning: Man kan skriva unchecked ) public T[] makearray(int size) { return (T[]) new Object[size]; 15
16 Parametrisering unchecked ) public T[] makearray(int size) { return (T[]) new unchecked ) - Är ett exempel på en Annotation - Undertrycker alla varningar för metoden makearray(). Kompileringen går problemfritt. 16
17 Parametrisering Komplikationer Problem: Det går inte att använda compareto()eftersom den inte finns för alla typer. Lösning: Det går att koppla en paremtriserad typ till ett interface eller en klass. Metoden compareto()är definierad i gränsnittet Comparable. Exempel: public class MyClass<T> extends Comparable<T> {... Nu kan den parametriserade klassen endast hantera klasser som implementerar Comparable. compareto() kan användas. 17
18 Parametrisering Komplikationer Problem: Det går inte att använda compareto()eftersom den inte finns för alla typer. Lösning: Det går att koppla en paremtriserad typ till ett interface eller en klass. Metoden compareto()är definierad i gränsnittet Comparable. Exempel: public class MyClass<T> extends Comparable<T> {... Nu kan den parametriserade klassen endast hantera klasser som implementerar Comparable. compareto() kan användas. Detta kallas för att koppla en parametrierad typ till ett interface/klass 18
19 Abstrakt datatyp 19
20 Abstrakt datatyp(adt) - En ADT beskriver vad man kan göra med en typ men inte hur den här implementerad: ADT MyClass() append() tostring() Implementering 20
21 Abstrakt datatyp(adt) - En ADT beskriver vad man kan göra med en typ men inte hur den här implementerad: ADT MyClass() append() tostring() Implementering - I java motsvaras en ADT oftast av ett gränssnitt som beskriver vilka metoder som ska finnas med i en ADT. 21
22 Abstrakt datatyp(adt) - Exempel - En lista är en abstrakt datatyp är finit och ordnad, dvs alla objekt I listan har en viss plats motsvarar begreppet sekvens i matematiken Man kan definiera vilka med metoder som ska finnas med för en lista 22
23 Lista Gränsnitt - Vad ska man kunna göra med en lista? Svar: I Java motsvaras en lista av gränssnittet List som bland annat innehåller följande metoder: boolean isempty() boolean addelement(e element) boolean add(int index, E element) E get(int index) E remove(int index)... 23
24 Lista Implementation - Det är inte specifierad hur en lista ska implementeras, men två vanliga metoder är: med hjälp av en array som en länkad struktur 24
25 Lista Implementeras med hjälp av en array - I klassen ArrayList representeras listan av en array T[] som består av 10 celler: T 25
26 Lista Implementeras med hjälp av en array - I klassen ArrayList representeras listan av en array T[] som består av 10 celler: T - När arrayen blir full, så skapas det en större array och innehåller från den gamla arrayen kopieras över till den nya: Detta tar tid 26
27 Lista Implementeras med hjälp av en array - I klassen ArrayList representeras listan av en array T[] som består av 10 celler: T - När arrayen blir full, så skapas det en större array och innehåller från den gamla arrayen kopieras över till den nya: Detta tar tid - I en array har vi random access vilket innebär att vi kan komma åt element var som helst o arrayen på konstant tid 27
28 Lista Implementeras med en länkad struktur - en länkad struktur består av noder 28
29 Implementeras med en länkad struktur - en länkad struktur består av noder data data data - varje nod består av data 29
30 Implementeras med en länkad struktur - en länkad struktur består av noder data data data - varje nod består av data och en pekare till nästa nod 30
31 Implementeras med en länkad struktur - en länkad struktur består av noder data data data - varje nod består av data och en pekare till nästa nod - Då den sista noden inte länkas till någon nod, har den en nullpekare: 31
32 Implementeras med en länkad struktur - en länkad struktur består av noder data data data - varje nod består av data och en pekare till nästa nod - Då den sista noden Inte länkas till någon noden, så har den ingen pekare - För att kunna arbeta med den länkade strukturen, räcker det med att känna till den första noden. 32
33 Implementeras med en länkad struktur data data data Den här strukturen kallas för enkellänkad lista 33
34 Enkellänkade listor klassen Node Noderna implementeras med hjälp av klassen Node: private class Node<T> { T data; Node next; Node(T v, Node n) { data=v; next=n; data next data next data next 34
35 Enkellänkade listor klassen MyLinkedList Den enkellänkade listan representeras av klassen MyLinkedList<T>: public class MyLinkedList<T> { private class Node<T> { T data; Node next; Node(T v, Node n) { data=v; next=n; data next data next data next private Node<T> head = null; 35
36 Enkellänkade listor Operationer 36
37 Enkellänkade listor Operationer - Sätt in ett nytt värde - Hämta värdet i en nod i en viss position - Ta bort ett värde 37
38 Enkellänkade listor Operationer addfirst(t data) 38
39 Enkellänkade listor Operationer addfirst(t data) public void addfirst(t v) { Node newhead = new Node(v,head); head=newhead; 39
40 Enkellänkade listor Operationer addfirst(t data) public void addfirst(t v) { Node newhead = new Node(v,head); head=newhead; head 40
41 Enkellänkade listor Operationer addfirst(t data) public void addfirst(t v) { Node newhead = new Node(v,head); head=newhead; head addfirst(2) 41
42 Enkellänkade listor Operationer addfirst(t data) public void addfirst(t v) { Node newhead = new Node(v,head); head=newhead; head addfirst(2) newhead data next 2 42
43 Enkellänkade listor Operationer addfirst(t data) public void addfirst(t v) { Node newhead = new Node(v,head); head=newhead; head head addfirst(2) data next 2 43
44 Enkellänkade listor Operationer addfirst(t data) Den enkellänkade listan ser nu ut så här: head data next 2 44
45 Enkellänkade listor Operationer addfirst(t data) public void addfirst(t v) { Node newhead = new Node(v,head); head=newhead; head addfirst(3) data next 2 45
46 Enkellänkade listor Operationer addfirst(t data) public void addfirst(t v) { Node newhead = new Node(v,head); head=newhead; head addfirst(3) data next 3 data next 2 data next 2 46
47 Enkellänkade listor Operationer addfirst(t data) public void add(t v) { Node newhead = new Node(v,head); head=newhead; head head addfirst(3) data next 3 data next 2 data next 2 47
48 Enkellänkade listor Operationer addfirst(t data) Den enkellänkade listan ser nu ut så här: head data next 3 data next 2 48
49 Enkellänkade listor Operationer get(int index) public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) { break; currentnode = currentnode.next; currentindex++; return currentnode.data; 49
50 Enkellänkade listor Operationer get(int index) public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; currentnode = currentnode.next; currentindex++; return currentnode.data; head data next 3 index 1 data next 2 50
51 Enkellänkade listor Operationer get(int index) public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; currentnode = currentnode.next; currentindex++; return currentnode.data; head data next 3 index 1 currentindex 0 currentnode data next 2 51
52 Enkellänkade listor Operationer get(int index) public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; currentnode = currentnode.next; currentindex++; return currentnode.data; head data next 3 index 1 currentindex 0 currentnode data next 2 52
53 Enkellänkade listor Operationer get(int index) public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; currentnode = currentnode.next; currentindex++; return currentnode.data; head data next 3 index 1 currentindex 0 currentnode data next 2 53
54 Enkellänkade listor Operationer get(int index) public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; currentnode = currentnode.next; currentindex++; return currentnode.data; head data next 3 index 1 currentindex 0 currentnode data next 2 54
55 Enkellänkade listor Operationer get(int index) public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; currentnode = currentnode.next; currentindex++; return currentnode.data; head data next 3 index 1 currentindex 0 currentnode data next 2 55
56 Enkellänkade listor Operationer get(int index) public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; currentnode = currentnode.next; currentindex++; return currentnode.data; head data next 3 index 1 currentindex 0 currentnode data next 2 56
57 Enkellänkade listor Operationer get(int index) public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; currentnode = currentnode.next; currentindex++; return currentnode.data; head data next 3 index 1 currentindex 0 currentnode data next 2 57
58 Enkellänkade listor Operationer get(int index) public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; currentnode = currentnode.next; currentindex++; return currentnode.data; head data next 3 index 1 currentindex 1 currentnode data next 2 58
59 Enkellänkade listor Operationer get(int index) public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; currentnode = currentnode.next; currentindex++; return currentnode.data; head data next 3 index 1 currentindex 1 currentnode data next 2 59
60 Enkellänkade listor Operationer get(int index) public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; currentnode = currentnode.next; currentindex++; return currentnode.data; head data next 3 index 1 currentindex 1 currentnode data next 2 60
61 Enkellänkade listor Operationer get(int index) public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; currentnode = currentnode.next; currentindex++; return currentnode.data; head data next 3 index 1 currentindex 1 currentnode data next 2 61
62 Enkellänkade listor Operationer get(int index) public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; currentnode = currentnode.next; currentindex++; return currentnode.data; head data next 3 index 1 currentindex 1 currentnode data next 2 62
63 Enkellänkade listor Operationer get(int index) public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; currentnode = currentnode.next; currentindex++; return currentnode.data; head data next 3 index 1 currentindex 1 currentnode data next 2 63
64 Enkellänkade listor Operationer get(int index) public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; currentnode = currentnode.next; currentindex++; return currentnode.data; head data next 3 index 1 currentindex 1 currentnode data next 2 64
65 Enkellänkade listor Operationer get(int index) public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; currentnode = currentnode.next; currentindex++; return currentnode.data; head data next 3 Värdet 2 returneras! currentnode data next 2 65
66 Enkellänkade listor Operationer remove(int index) public T remove(int index) { if(index = 0 && head!= null) { head=head.next; else { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; else { currentnode = currentnode.next; currentindex++; if(currentnode.next!= null) { currentnode.next = currentnode.next.next; 66
67 Enkellänkade listor Operationer remove(int index) public T remove(int index) {... if(currentnode.next!= null) { currentnode.next = currentnode.next.next; data data data currentnode 67
68 Enkellänkade listor Operationer remove(int index) public T remove(int index) {... if(currentnode.next!= null) { currentnode.next = currentnode.next.next; data data data currentnode 68
69 Enkellänkade listor Operationer remove(int index) public T remove(int index) {... if(currentnode.next!= null) { currentnode.next = currentnode.next.next; data data data currentnode 69
70 Enkellänkade listor Operationer remove(int index) public T remove(int index) {... if(currentnode.next!= null) { currentnode.next = currentnode.next.next; data data data currentnode 70
71 Enkellänkade listor Operationer remove(int index) public T remove(int index) {... if(currentnode.next!= null) { currentnode.next = currentnode.next.next; data data currentnode 71
72 Enkellänkade listor Operationer remove(int index) public T remove(int index) {... if(currentnode.next!= null) { currentnode.next = currentnode.next.next; data data currentnode Javas garbage collection tar hand om den nod som togs bort. 72
73 Enkellänkade listor Operationer add(t v,int index) //Lägg till en ny nod sist i listan public T add(t v, int index) {... if(currentnode.next == null) { Node newnode = new Node(v,null); currentnode.next = newnode; data data currentnode 73
74 Enkellänkade listor Operationer add(t v,int index) //Lägg till en ny nod sist i listan public T add(t v, int index) {... if(currentnode.next == null) { Node newnode = new Node(v,null); currentnode.next = newnode; data data currentnode newnode T 74
75 Enkellänkade listor Operationer add(t v,int index) //Lägg till en ny nod sist i listan public T add(t v, int index) {... if(currentnode.next == null) { Node newnode = new Node(v,null); currentnode.next = newnode; data data currentnode newnode T 75
76 Enkellänkade listor Operationer add(t v,int index) //Lägg till en ny nod sist i listan public T add(t v,int index) {... if(currentnode.next == null) { Node newnode = new Node(v,null); currentnode.next = newnode; data data currentnode newnode T 76
77 Enkellänkade listor Operationer add(t v,int index) //Lägg till en ny nod sist i listan public T add(t v,int index) {... if(currentnode.next == null) { Node newnode = new Node(v,null); currentnode.next = newnode; data data currentnode newnode T 77
78 Enkellänkade listor Operationer add(t v,int index) //Lägg till en ny nod sist i listan public T add(t v,int index) {... if(currentnode.next == null) { Node newnode = new Node(v,null); currentnode.next = newnode; data data currentnode newnode T 78
79 Enkellänkade listor Operationer add(t v,int index) //Lägg till en ny nod sist i listan public T add(t v,int index) {... if(currentnode.next == null) { Node newnode = new Node(v,null); currentnode.next = newnode; data data T currentnode 79
80 Enkellänkade listor Operationer tostring() public String tostring() { Node currentnode = head; StringBuilder res = new StringBuilder(); while (currentnode!= null) { res.append(current.data + " "); currentnode = currentnode.next; return res.tostring(); 80
81 Olika typer av länkade listor Enkellänkad lista: Varje nod pekar på nästa nod Klassen känner till den första noden i listan head data data data 81
82 Olika typer av länkade listor Enkellänkad lista: Varje nod pekar på nästa nod Klassen känner till den första noden i listan head data data data Dubbellänkad lista: Varje nod pekar på både föregående och nästa nod Klassen känner till den första och den sista noden i listan Klassen LinkedList i java är dubbellänkad head end prev data next 82
83 Olika typer av länkade listor Enkellänkad lista: Varje nod pekar på nästa nod Klassen känner till den första noden i listan I vissa implementationer känner man även till den sista noden också head data data data Dubbellänkad lista: Varje nod pekar på både föregående och nästa nod Klassen känner till den första och den sista noden i listan Klassen LinkedList i java är dubbellänkad head end prev data next 83
84 Enkellänkade listor Tidskomplexitet Hämta värde: - Först i listan: O(1) - På plats n : O(n) Insättning/borttagning: - Först i listan: O(1) - På plats n : O(n) - Själva insättningen/borttagningen: O(1) - Sist i listan: O(1) om det finns en pekare till det sista noden annars O(n) 84
85 Andra länkade strukturer Binära träd 85
86 Binärt sökträd - Exempel key
87 Binärt sökträd - Exempel key key == 5? Färdig key < 5? Sök i vänster barn key > 5? Sök i höger barn 87
88 Binärt sökträd - Exempel key key == 5? Färdig key < 5? Sök i vänster barn key > 5? Sök i höger barn 88
89 Binärt sökträd - Exempel key key == 3? Färdig key < 3? Sök i vänster barn key > 3? Sök i höger barn 89
90 Binärt sökträd - Exempel key key == 3? Färdig key < 3? Sök i vänster barn key > 3? Sök i höger barn 90
91 Binärt sökträd - Exempel key key == 2? Färdig key < 2? Sök i vänster barn key > 2? Sök i höger barn 91
92 Binärt sökträd - Exempel key key == 8? Färdig key < 8? Sök i vänster barn key > 8? Sök i höger barn92
93 Binärt sökträd - Exempel key key == 8? Färdig key < 8? Sök i vänster barn key > 8? Sök i höger barn93
94 Binärt sökträd - Exempel key key == 7? Färdig key < 7? Sök i vänster barn key > 7? Sök i höger barn94
95 Binärt sökträd - Exempel
96 Binärt sökträd Datastruktur - Binärt sökträd består av noder med följande innehåll: - nyckel - data - pekare till vänster barn - pekare till höger barn Left child key data Right child 96
97 Binärt sökträd Datastruktur
98 Binärt sökträd klassen MyBinaryTree public class BinaryTree<T> { private class Node<T> { T data; Node left; Node right; Node(T v, Node l, Node r) { data=v; Left=l; right=r; private Node<T> root; 98
99 Träd - Fakta ROT Noden högst upp i trädet Inre noder Noder som har en förälder och minst ett barn LÖV (TERMINAL) Noderna längst ner i trädet 99
100 Träd - Fakta ROT Noden högst upp i trädet Inre noder Noder som har en förälder och minst ett barn LÖV (TERMINAL) Noderna längst ner i trädet 100
101 Träd - Fakta ROT Noden högst upp i trädet Inre noder Noder som har en förälder och minst ett barn LÖV (TERMINAL) Noderna längst ner i trädet 101
102 Obalanserat träd - Exempel Antal noder: 9 Höjd: 9 Söktid: O(n) 102
103 Balanserat träd - Exempel Antal noder: 9 Höjd: 4 Söktid: O(log n) 103
104 Hur kan vi garantera att ett träd är balanserat? Idé: Varje gång vi lägg in en nod i trädet, kontrollerar vi att det är i balans. Metoder: - AVL-träd - Röd-Svarta träd - Heap träd Påverkar inte tidskomplexiteten: - Man söker på nervägen och balanserar på tillbakavägen. 104
105 Balanserade träd komplexitet Insättning: O(log n) borttagning: O(log n) Sökning: O(log n) Traversering: O(n) - Man går igenom trädet och besöker varje nod exakt en gång. Detta görs med hjälp av rekursion. 105
106 Sortering i listor - De sorteringsalgoritmer vi gick igenom förra gången fungerar på arrayer eftersom de bygger på random access 106
107 Sortering i listor - De sorteringsalgoritmer vi gick igenom förra gången fungerar på arrayer eftersom de bygger på random access - Algoritmerna är väldigt ineffektiva på länkade strukturer 107
108 Sortering i listor - De sorteringsalgoritmer vi gick igenom förra gången fungerar på arrayer eftersom de bygger på random access - Algoritmerna är väldigt ineffektiva på länkade strukturer - Vissa går att modifiera för länkade strukturer Exempel: Instickssortering och merge sort 108
109 Sortering i listor - De sorteringsalgoritmer vi gick igenom förra gången fungerar på arrayer eftersom de bygger på random access - Algoritmerna är väldigt ineffektiva på länkade strukturer - Vissa går att modifiera för länkade strukturer Exempel: Instickssortering och merge sort Alternativ: Lägg till datan i sorterad ordning, Enkelt i länkade listor Opraktiskt att göra i en array Kan vara bättre att använda ett binärt sökträd 109
110 Komplexitet för olika listimplementationer och sökträd Array Länkad lista Binärt sökträd Iteration O(n) O(n) O(n) Söka efter ett värde O(n) O(n) O(log n) Hämta värde på index i O(1) O(n) Sätta in värde först O(n) O(1) Sätta in värde på index i O(n) O(n) Sätta in värdet sist O(1) O(1) eller O(n) Sätta in ett värde sorterat O(n) O(n) O(log n) Ta bort det första värdet O(n) O(1) Ta bort värdet på index i O(n) O(n) Ta bort ett givet värde O(n) O(n) O(log n) 110
111 Komplexitet för for-loop for(int i = 0; i < collection.size(); i++) { // Do something with collection[i] 111
112 Komplexitet för for-loop for(int i = 0; i < collection.size(); i++) { // Do something with collection[i] Array Länkad lista Loop med indexering O(n ) O(n 2) 112
113 Komplexitet för for-each-loop for(t data: collection.size()) { // Do something with data Array Länkad lista For-each loop O(n) O(n ) For-each loopen loopar igenom listan med hjälp av en Iterator mer om detta nästa gång 113
114 ADT- Vilken datastruktur ska man välja? - Beror på uppgiften! Tips: Tänk igenom vilka operationer du behöver utföra ofta Om man ska söka ofta: Använd binärt sökträd eller en hashtabell Om man ska loopa igenom samlingen ofta: - Om antalet element är konstant använd array - Om antalet element varierar mycket eller är okänt: använd en länkad lista - Om man ofta behöver sätta in värden i samlingen: använd en hashtabell 114
115 Undantag(Exception) 115
116 Undantag (Exception) - Om något konstigt händer i en klass kan man göra följande: - Kasta ett undantag i klassen tala om att något konstigt hänt - Låta en annan klass ta hand om felet felet hanteras utan att programmet kraschar 116
117 Undantag (Exception) Hur kastar man undantag? Exempel: public void remove() throws UnsupportedOperationException { throw new UnsupportedOperationException(); UnsupportedOperationException Undantag som talar om att denna operation inte är tillåten. Används till exempel när klassen implementerar ett gränssnitt och gränssnittet innehåller metoder som inte ska ingå i klassen. Exempel: Man kan inte ta bort element mitt i stacken men vi behöver implementera remove() för kunna använda Iterator. 117
118 Undantag (Exception) Hur kastar man undantag? Exempel: public void remove() throws UnsupportedOperationException { throw new UnsupportedOperationException(); throws Används för att tala om att den här metoden kastar ett undantag throw Används för att kasta undantaget 118
119 Undantag (Exception) Hur kastar man undantag? UnsupportedOperationException - en undantagsklass som ärver från klassen Exception. new UnsupportedOperationException(); - skapar en instans av klassen 119
120 Undantag (Exception) Klassdiagram Throwable Error Exception RuntimeException UnsupportedOperation Exception
121 Undantag (Exception) Klassdiagram Throwable Error Error Fel som inte beror på programmet själv utan på något som sker utanför. Går inte att hantera. Exempel: Programmet behöver mer minne men det har tagit slut. 121
122 Undantag (Exception) Klassdiagram Throwable Error Exception RuntimeException RuntimeException Beror på misstag i programmeringen 122
123 Undantag (Exception) RuntimeException Beror på misstag i programmeringen Exempel 1: ArrayIndexOutOfBoundsException - Händer när man försöker göra använda ett index utanför en array. String[] array = new String[4]; array[-1] = "Outside"; array[2] = "inside"; array[5] = "Outside"; //error // ok // error 123
124 Undantag (Exception) RuntimeException Beror på misstag i programmeringen Exempel 2a: NullPointerException - Händer när man försöker använda null. int number = 1 + null; // error 124
125 Undantag (Exception) RuntimeException Beror på misstag i programmeringen Exempel 2b: NullPointerException - Händer när man försöker använda null. Node current = null; current = current.next; // ok! // error! current: next saknas om current har värdet null 125
126 Undantag (Exception) RuntimeException Beror på misstag i programmeringen Åtgärd Rätta till programmet. Hur hitta felet i programmet? Tips: Gör utskrifter med System.out.println(..); på olika ställen i programmet. 126
127 Undantag (Exception) Klassdiagram Throwable Error Exception UnsupportedOperation Exception... Övriga exception - Fel som är svåra att förutse - Man kan hantera undantaget. 127
128 Undantag (Exception) Övriga exception - Fel som är svåra att förutse - Man kan hantera undantaget. Passiv hantering Metoden kastar vidare undantaget som remove() kastar. Exempel: public void removeeverything(iterator<integer> it) throws UnsupportedOperationException { while(it.hasnext()) { Integer i = it.next(); it.remove(); 128
129 Undantag (Exception) Övriga exception - Fel som är svåra att förutse - Man kan hantera undantaget. Aktiv hantering Metoden fångar undantaget och utför en åtgärd. try { // satser man försöker exekvera catch (Exception e) { // Här hamnar man om ett undantag kastades // när satserna exekverades 129
130 Undantag (Exception) Övriga exception - Fel som är svåra att förutse - Man kan hantera undantaget. Aktiv hantering Metoden fångar undantaget och utför en åtgärd. Exempel: public void removeeverything(iterator<integer> it){ while(it.hasnext()) { Integer i = it.next(); try { it.remove(); catch(unsupportedoperationexception e) { System.err.println (e + "was handled in" + "in removeeverything."); 130
131 Undantag (Exception) Övriga exception - Fel som är svåra att förutse - Man kan hantera undantaget. Aktiv hantering Metoden fångar undantaget och utför en åtgärd. Vad göra i catch-blocket? - Skriva ett felmeddelande: System.err.println(e + "was handled in" + "in removeeverything."); System.err.println(""); Används för att skriva ut något på error-strömmen istället för out-strömmen. 131
132 Undantag (Exception) Vad göra i catch-blocket? - Skriva ett felmeddelande: System.err.println(e + "was handled in" + "in removeeverything."); System.err.println(""); Används för att skriva ut något på error-strömmen istället för out-strömmen. - Kasta ett nytt undantag - Tilldela andra värden på variabler osv. 132
133 Undantag (Exception) Vilka undantag måste man hantera? Alla undantag utom Error och RuntimeException måste hanteras. Om man vill kasta ett exception som inte finns i någon undantagsklass? Skapa en nya undantagsklass. 133
134 Undantag (Exception) Skapa en egen undantagsklass till klassen MyLinkedList<T>. 1. Använd klassen Exception som superklass, dvs skapa en klass som ärver från den. public class MyLinkedListException extends Exception {
135 Undantag (Exception) Skapa en egen undantagsklass till klassen MyLinkedList<T>. 1. Använd klassen Exception som superklass, dvs skapa en klass som ärver från den. public class MyLinkedListException extends Exception { Skapa de konstruktorer du vill använda. // default konstruktor public MyLinkedListkException() { super(); 135
136 Undantag (Exception) Skapa en egen undantagsklass till klassen MyLinkedList<T>. 2. Skapa de konstruktorer du vill använda. // default konstruktor public MyLinkedListException() { super(); // konstruktor om man vill skapa ett undantag med // ett meddelande public MyLinkedListException(String message) { super(message); 136
137 Undantag (Exception) Skapa en egen undantagsklass till klassen MyLinkedList<T>. 2. Skapa de konstruktorer du vill använda. // konstruktor om man vill skapa ett undantag med // ett meddelande och ett (nytt) undantag. // Man kan skapa en kedja av undantag. public MyLinkedListException(String message, Throwable cause) { super(message, cause); 137
138 Undantag (Exception) Skapa en egen undantagsklass till klassen MyLinkedLList<T>. 2. Skapa de konstruktorer du vill använda. // konstruktor om man vill skapa ett undantag med // ett (nytt) undantag. // Man kan skapa en kedja av undantag. public MyLinkedListException(Throwable cause) { super(cause); 138
139 Undantag (Exception) Skapa en egen undantagsklass till klassen MyLinkedList<T>. public class MyLinkedListException extends Exception { public MyLinkedListException() { super(); public MyLinkedListException(String message) { super(message); public MyLinkedListException(String message, Throwable cause) { super(message, cause); public MyLinkedListException(Throwable cause) { super(cause); 139
140 Undantag (Exception) Använda MyLinkedListException i klassen MyLinkedList<T>. Vad händer om vi anropar get(index)med ett index som ligger utanför listans storlek, till exempel index<0, eller om listan är tom? 140
141 Undantag (Exception) Använda MyLinkedListException i klassen MyLinkedList<T>. Vad händer om vi anropar get(index) på en tom enkellänkad lista? head index 1 public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; currentnode = currentnode.next; currentindex++; return currentnode.data; 141
142 Undantag (Exception) Använda MyLinkedListException i klassen MyLinkedList<T>. Vad händer om vi anropar get(index) på en tom enkellänkad lista? head index 1 currentnode currentindex 0 public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; currentnode = currentnode.next; currentindex++; return currentnode.data; 142
143 Undantag (Exception) Använda MyLinkedListException i klassen MyLinkedList<T>. Vad händer om vi anropar get(index) på en tom enkellänkad lista? head index 1 currentnode currentindex 0 public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; currentnode = currentnode.next; currentindex++; return currentnode.data; 143
144 Undantag (Exception) Använda MyLinkedListException i klassen MyLinkedList<T>. Vad händer om vi anropar get(index) på en tom enkellänkad lista? head index 1 currentnode currentindex 0 public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; currentnode = currentnode.next; currentindex++; return currentnode.data; 144
145 Undantag (Exception) Använda MyLinkedListException i klassen MyLinkedList<T>. Vad händer om vi anropar get(index) på en tom enkellänkad lista? head index 1 currentnode currentindex 0 public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; currentnode = currentnode.next; currentindex++; return currentnode.data; Programmet kraschar eftersom currentnode har värdet null 145
146 Undantag (Exception) Istället för att krascha programmet kan vi kasta MyLinkedListException: public T get(int index) throws MyLinkedListException { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; if(currentnode.next!= null) { currentnode = currentnode.next; currentindex++; else { throw new MyLinkedListException(); if(currentnode!= null) { return currentnode.data; else { throw new MyLinkedListException(); 146
147 Undantag (Exception) Istället för att krascha programmet kan vi kasta MyLinkedListException: public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; if(currentnode.next!= null) { currentnode = currentnode.next; currentindex++; else { throw new MyLinkedListException(); if(currentnode!= null) { return currentnode.data; else { throw new MyLinkedListException(); 147
148 Undantag (Exception) Istället för att krascha programmet kan vi kasta MyLinkedListException: public T get(int index) { Node currentnode = head; int currentindex = 0; while (currentnode!= null) { if (currentindex == index) break; if(currentnode.next!= null) { currentnode = currentnode.next; currentindex++; else { throw new MyLinkedListException(); if(currentnode!= null) { return currentnode.data; else { throw new MyLinkedListException(); 148
149 Undantag (Exception) - Kasta med eller utan meddelande: throw new MyLinkedListException(); throw new MyLinkedListException("Information"); - Metoder man kan använda för att få information om undantaget: String getmessage() returnerar meddelandet eller null om det inte finns String tostring() returnerar en sträng som innehåller namnet på undantaget och eventuellt meddelande catch (MyLinkedListException e) { System.out.println("Something went wrong " + e); 149
150 Lab 2, del 2 - Sökning Kandidat: - Ni får en given klass med kod för linjär sökning binär sökning, rekursiv binär sökning, iterativ - Koden är skriven för arrayer med heltal, int[] Uppgift -- Gör om klassen så att den blir generisk -- Gör om koden så att den fungerar för generisk ArrayList<T> Master: Implementera Binärt sökträd 150
151 Kommande veckor Sökning och sortering Deadline lab 2: 29/9 Tema datastrukturer, paket, iteratorer mm (v ) Föreläsning om iteratorer, stackar och köer mm Två labtillfällen 151
152 Jobba själv - Labbar Lab2 - Gör progammeringsövningar Från boken - Läs om veckans område Sökning Sortering Komplexitet - Läs inför nästa vecka Parametriserade typer Länkade strukturer Stackar och köer Undantag 152
Länkade strukturer, parametriserade typer och undantag
Länkade strukturer, parametriserade typer och undantag Programmering för språkteknologer 2 Sara Stymne 2013-09-18 Idag Parametriserade typer Listor och länkade strukturer Komplexitet i länkade strukturer
Lösningsförslag till exempeltenta 1
Lösningsförslag till exempeltenta 1 1 1. Beskriv hur binärsökning fungerar. Beskriv dess pseudokod och förklara så klart som möjligt hur den fungerar. 2 Uppgift 1 - Lösning Huvudidé: - Titta på datan i
Föreläsning 9 Innehåll
Föreläsning 9 Innehåll Binära sökträd algoritmer för sökning, insättning och borttagning, implementering effektivitet balanserade binära sökträd, AVL-träd Abstrakta datatyperna mängd (eng. Set) och lexikon
Föreläsning 4 Innehåll. Abstrakta datatypen lista. Implementering av listor. Abstrakt datatypen lista. Abstrakt datatyp
Föreläsning 4 Innehåll Abstrakta datatypen lista Definition Abstrakta datatypen lista egen implementering Datastrukturen enkellänkad lista Nästlade klasser statiska nästlade klasser inre klasser Listklasser
Föreläsning 2. Länkad lista och iterator
Föreläsning 2 Länkad lista och iterator Föreläsning 2 Länkad-lista Lista implementerad med en enkellänkad lista Iterator Implementering av en Iterator Dubbellänkad lista och cirkulär lista LinkedList JCF
Datastrukturer. föreläsning 3. Stacks 1
Datastrukturer föreläsning 3 Stacks 1 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
Abstrakt datatyp. -Algoritmer och Datastrukturer- För utveckling av verksamhet, produkter och livskvalitet.
-Algoritmer och Datastrukturer- Abstrakt datatyp Datatyp för en variabel Betecknar i ett programmeringsspråk den mängd värden variabeln får anta. T ex kan en variabel av typ boolean anta värdena true och
Föreläsning 4 Innehåll
Föreläsning 4 Innehåll Abstrakta datatypen lista Datastrukturen enkellänkad lista Nästlade klasser statiskt nästlade klasser inre klasser Listklasser i Java Implementera abstrakta datatyperna stack och
Föreläsning 2. Länkad lista och iterator
Föreläsning 2 Länkad lista och iterator Föreläsning 2 Länkad-lista Lista implementerad med en enkellänkad lista Iterator Implementering av en Iterator Dubbellänkad lista och cirkulär lista LinkedList JCF
Föreläsning 3 Datastrukturer (DAT037)
Föreläsning 3 Datastrukturer (DAT037) Fredrik Lindblad 1 2016-11-07 1 Slides skapade av Nils Anders Danielsson har använts som utgångspunkt Se http://wwwcsechalmersse/edu/year/2015/course/dat037 Förra
Föreläsning 9 Datastrukturer (DAT037)
Föreläsning Datastrukturer (DAT07) Fredrik Lindblad 27 november 207 Slides skapade av Nils Anders Danielsson har använts som utgångspunkt Se http://wwwcsechalmersse/edu/year/20/course/dat07 Innehåll 2
Föreläsning 14 Innehåll
Föreläsning 14 Innehåll Abstrakta datatyper, datastrukturer Att jämföra objekt övriga moment i kursen Om tentamen Skriftlig tentamen både programmeringsuppgifter och teoriuppgifter Hitta fel i fingerade
Föreläsning 2 Datastrukturer (DAT037)
Föreläsning 2 Datastrukturer (DAT037) Fredrik Lindblad 1 2016-11-02 1 Slides skapade av Nils Anders Danielsson har använts som utgångspunkt. Se http://www.cse.chalmers.se/edu/year/2015/course/dat037 Tidskomplexitet
TDDC30 Programmering i Java, Datastrukturer och Algoritmer Lektion 2. Länkade listor Stackar Köer MyList Iteratorer Lab 2 Exceptions Paket
TDDC30 Programmering i Java, Datastrukturer och Algoritmer Lektion 2 Länkade listor Stackar Köer MyList Iteratorer Lab 2 Exceptions Paket 1 Länkade listor Likadant som i Ada-kursen. 2 Stack MyStack MyStack
Föreläsning Datastrukturer (DAT036)
Föreläsning Datastrukturer (DAT036) Nils Anders Danielsson 2013-11-25 Idag Starkt sammanhängande komponenter Duggaresultat Sökträd Starkt sammanhängande komponenter Uppspännande skog Graf, och en möjlig
if (n==null) { return null; } else { return new Node(n.data, copy(n.next));
Inledning I bilagor finns ett antal mer eller mindre ofullständiga klasser. Klassen List innehåller några grundläggande komponenter för att skapa och hantera enkellänkade listor av heltal. Listorna hålls
TDDC30. Objektorienterad programmering i Java, datastrukturer och algoritmer. Föreläsning 9 Jonas Lindgren, Institutionen för Datavetenskap, LiU
TDDC30 Objektorienterad programmering i Java, datastrukturer och algoritmer. Föreläsning 9 Jonas Lindgren, Institutionen för Datavetenskap, LiU På denna föreläsning: Prioritetskö Heap Representation som
TDDE10 m.fl. Objektorienterad programmering i Java Föreläsning 6 Erik Nilsson, Institutionen för Datavetenskap, LiU
TDDE10 m.fl. Objektorienterad programmering i Java Föreläsning 6 Erik Nilsson, Institutionen för Datavetenskap, LiU På denna föreläsning: Mer om Interface Generiska klasser Undantag Nästlade klasser 1
Hitta k största bland n element. Föreläsning 13 Innehåll. Histogramproblemet
Föreläsning 13 Innehåll Algoritm 1: Sortera Exempel på problem där materialet i kursen används Histogramproblemet Schemaläggning Abstrakta datatyper Datastrukturer Att jämföra objekt Om tentamen Skriftlig
Tommy Färnqvist, IDA, Linköpings universitet
Föreläsning 9 Pekare, länkade noder, länkade listor TDDD86: DALP Utskriftsversion av föreläsning i Datastrukturer, algoritmer och programmeringsparadigm 25 september 2015 Tommy Färnqvist, IDA, Linköpings
Stackar, köer, iteratorer och paket
Stackar, köer, iteratorer och paket Programmering för språkteknologer 2 Sara Stymne 2013-09-18 Idag Paket Stackar och köer Array resp länkad struktur Iteratorer Javadoc Kommentarer lab 1 Bra att de flesta
Föreläsning 2 Datastrukturer (DAT037)
Föreläsning 2 Datastrukturer (DAT037) Fredrik Lindblad 1 1 november 2017 1 Slides skapade av Nils Anders Danielsson har använts som utgångspunkt. Se http://www.cse.chalmers.se/edu/year/2015/course/dat037
Föreläsning 3. Stack
Föreläsning 3 Stack Föreläsning 3 ADT Stack Stack JCF Tillämpning Utvärdera ett postfix uttryck Stack implementerad med en array Stack implementerad med en länkad lista ADT Stack Grundprinciper: En stack
Listor. Koffman & Wolfgang kapitel 2, avsnitt , och 2.9
Listor Koffman & Wolfgang kapitel 2, avsnitt 2.1 2.3, 2.5 2.6 och 2.9 Figur 2.1, sid 63 java.util.list, med dess implementeringar 2 List och primitiva typer En array kan innehålla primitiva typer: int[],
TDDC30. Objektorienterad programmering i Java, datastrukturer och algoritmer. Föreläsning 4 Erik Nilsson, Institutionen för Datavetenskap, LiU
TDDC30 Objektorienterad programmering i Java, datastrukturer och algoritmer. Föreläsning 4 Erik Nilsson, Institutionen för Datavetenskap, LiU På denna föreläsning: Interface Generiska klasser Undantag
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
Tentamen Programmeringsteknik II 2018-10-19 Skrivtid: 8:00 13:00 Tänk på följande Skriv läsligt. Använd inte rödpenna. Skriv bara på framsidan av varje papper. Lägg uppgifterna i ordning. Skriv uppgiftsnummer
Föreläsning 12. Länkade listor
Föreläsning 12 Länkade listor Jämför en array med en länkad lista m in n e t Array (med 5 element): + effektiv vid hämtning - ineffektiv vid insättning och borttagning Länkad lista (med 5 element): + effektiv
Tentamen i Algoritmer & Datastrukturer i Java
Tentamen i Algoritmer & Datastrukturer i Java Hjälpmedel: Skrivhjälpmedel, miniräknare. Ort / Datum: Halmstad / 2010-03-16 Skrivtid: 4 timmar Kontaktperson: Nicolina Månsson Poäng / Betyg: Max 44 poäng
TDDC30. Objektorienterad programmering i Java, datastrukturer och algoritmer. Föreläsning 3 Jonas Lindgren, Institutionen för Datavetenskap, LiU
TDDC30 Objektorienterad programmering i Java, datastrukturer och algoritmer. Föreläsning 3 Jonas Lindgren, Institutionen för Datavetenskap, LiU På denna föreläsning: Abstrakta datatyper Listor Stackar
Sökning och sortering
Sökning och sortering Programmering för språkteknologer 2 Sara Stymne 2013-09-16 Idag Sökning Analys av algoritmer komplexitet Sortering Vad är sökning? Sökning innebär att hitta ett värde i en samling
TDDC30 Programmering i Java, Datastrukturer och Algoritmer Lektion 2. Laboration 2 Datastrukturer En liten uppgift Frågor
TDDC30 Programmering i Java, Datastrukturer och Algoritmer Lektion 2 Laboration 2 Datastrukturer En liten uppgift Frågor 1 Laboration 2 - Datastrukturer Länkade datastrukturer Stack Kö (En. Queue) Lista
TDDE10 m.fl. Objektorienterad programmering i Java Föreläsning 6 Erik Nilsson, Institutionen för Datavetenskap, LiU
TDDE10 m.fl. Objektorienterad programmering i Java Föreläsning 6 Erik Nilsson, Institutionen för Datavetenskap, LiU På denna föreläsning Generiska klasser Undantag Interface Nästlade klasser 1 Problem:
Lägg uppgifterna i ordning. Skriv uppgiftsnummer och din anmälningskod överst i högra hörnet på alla papper.
Tentamen Programmeringsteknik II 2018-05-28 Skrivtid: 0800 1300 Tänk på följande Lägg uppgifterna i ordning. Skriv uppgiftsnummer och din anmälningskod överst i högra hörnet på alla papper. Fyll i försättssidan
Föreläsning 10. ADT:er och datastrukturer
Föreläsning 10 ADT:er och datastrukturer ADT:er och datastrukturer Dessa två begrepp är kopplade till varandra men de står för olika saker. En ADT (abstrakt datatyp) är just abstrakt och är inte kopplad
Föreläsning 3 Innehåll. Generiska klasser. Icke-generisk lista ArrayList, skiss av implementering. Icke-generisk lista Risk för fel
Föreläsning 3 Innehåll Generiska klasser Implementera generiska klasser Exceptions Dokumentationekommentarer javadoc Enhetstestning - junit Man kan deklarera en eller flera typparametrar när man definierar
Datastrukturer i kursen. Föreläsning 8 Innehåll. Träd rekursiv definition. Träd
Föreläsning 8 Innehåll Datastrukturer i kursen Träd, speciellt binära träd egenskaper användningsområden implementering Undervisningsmoment: föreläsning 8, övningsuppgifter 8, lab 4 Avsnitt i läroboken:
Datastrukturer. Arrayer. Arrayer. Arrayer. Array av arrayer. Array av arrayer
Arrayer Samling av data Datastrukturer int[] minatelnummer = new int[30]; // allokering av tillräckligt // stort minnesutrymme Element refereras genom indexering ringa = minatelnummer[25]; // indexering
Föreläsning 10 Datastrukturer (DAT037)
Föreläsning 10 Datastrukturer (DAT037) Fredrik Lindblad 1 29 november 2017 1 Slides skapade av Nils Anders Danielsson har använts som utgångspunkt. Se http://www.cse.chalmers.se/edu/year/2015/course/dat037
Föreläsning 7. Träd och binära sökträd
Föreläsning 7 Träd och binära sökträd Föreläsning 7 Träd Binära träd Binärt sökträd som ADT Implementering av binärt sökträd Travestera binärt sökträd Sökning Insättning/borttagning Det är extra mycket
Repetition av OOP- och Javabegrepp
ArrayList Repetition av OOP- och Javabegrepp En lista i vilken man kan lagra objekt Implementerar List-interfacet Skiljer sig från ett vanligt endimensionellt fält: Dynamisk expanderar när den blir
F12 - Collections. ID1004 Objektorienterad programmering Fredrik Kilander
F12 - Collections ID1004 Objektorienterad programmering Fredrik Kilander fki@kth.se Collections (samlingar) En collection är ett objekt som fungerar som en samling av andra objekt En collection erbjuder
Föreläsning 1. Abstrakta datatyper, listor och effektivitet
Föreläsning 1 Abstrakta datatyper, listor och effektivitet Föreläsning 1 Datastrukturer Abstrakta DataTyper ADT Lista Lista och Java Collections Framework (ArrayList) Lista implementerad med en array Analys
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 Innehåll Prioritetsköer och heapar Prioritetsköer och heapar ADT prioritetskö Klassen PriorityQueue i java.util Implementering med lista ar Implementering av prioritetskö med heap Sortering
Föreläsning 10 Innehåll
Föreläsning 10 Innehåll Binära sökträd algoritmer för sökning, insättning och borttagning implementering effektivitet balanserade binära sökträd, AVL-träd Jämföra objekt interfacet Comparable Interfacet
Objektorienterad programmering i Java, datastrukturer och algoritmer. Föreläsning 4 Jonas Lindgren, Institutionen för Datavetenskap, LiU
TDDC30 Objektorienterad programmering i Java, datastrukturer och algoritmer. Föreläsning 4 Jonas Lindgren, Institutionen för Datavetenskap, LiU På denna föreläsning: Interface Generiska klasser Undantag
Repetition av OOP- och Javabegrepp
ArrayList Repetition av OOP- och Javabegrepp En lista i vilken man kan lagra objekt Implementerar List-interfacet Skiljer sig från ett vanligt endimensionellt fält: Dynamisk expanderar när den blir
TDDC30. Objektorienterad programmering i Java, datastrukturer och algoritmer. Föreläsning 3 Jonas Lindgren, Institutionen för Datavetenskap, LiU
TDDC30 Objektorienterad programmering i Java, datastrukturer och algoritmer. Föreläsning 3 Jonas Lindgren, Institutionen för Datavetenskap, LiU På denna föreläsning: Abstrakta datatyper Listor Stackar
Tentamen Programmeringsteknik II Inledning. Anmälningskod:
Tentamen Programmeringsteknik II 2016-01-11 Inledning I bilagan finns ett antal mer eller mindre ofullständiga klasser. Några ingår i en hierarki: List, SortedList, SplayList och ListSet enligt vidstående
Föreläsning 4 Datastrukturer (DAT037)
Föreläsning 4 Datastrukturer (DAT037) Fredrik Lindblad 1 2016-11-10 1 Slides skapade av Nils Anders Danielsson har använts som utgångspunkt Se http://wwwcsechalmersse/edu/year/2015/course/dat037 Förra
Föreläsning 9 Innehåll
Föreläsning 9 Innehåll Träd, speciellt binära träd egenskaper användningsområden implementering Datavetenskap (LTH) Föreläsning 9 HT 2017 1 / 31 Inlämningsuppgiften De föreläsningar som inlämningsuppgiften
Objektorienterad Programkonstruktion. Föreläsning 4 8 nov 2016
Objektorienterad Programkonstruktion Föreläsning 4 8 nov 2016 Nästade klasser I Java går det att deklarera en klass inuti en annan klass. Vi kallar detta för att en yttre klass innehåller en inre klass.
Föreläsning 11 Innehåll. Diskutera. Binära sökträd Definition. Inordertraversering av binära sökträd
Föreläsning Innehåll Diskutera Binära sökträd algoritmer för sökning, insättning och borttagning implementering effektivitet balanserade binära sökträd, AVL-träd Jämföra objekt interfacet Comparable Interfacet
Tentamen'('Datastrukturer,'algoritmer'och'programkonstruktion.'
Tentamen'('Datastrukturer,'algoritmer'och'programkonstruktion.' Skrivtid: 08.30 13.30 Hjälpmedel: Inga Lärare: Betygsgränser DVA104' Akademin)för)innovation,)design)och)teknik) Onsdag)2014:01:15) Caroline
Teoretisk del. Facit Tentamen TDDC kl (6) 1. (6p) "Snabba frågor" Alla svar motiveras väl.
Facit Tentamen TDDC30 2015-03-19 kl 08-12 1 (6) Teoretisk del 1. (6p) "Snabba frågor" Alla svar motiveras väl. a) Varför väljer man ofta synligheten private hellre än public för medlemsvariabler i en klass?
Föreläsning 3 Datastrukturer (DAT037)
Föreläsning 3 Datastrukturer (DAT037) Fredrik Lindblad 1 6 november 2017 1 Slides skapade av Nils Anders Danielsson har använts som utgångspunkt Se http://wwwcsechalmersse/edu/year/2015/course/dat037 1
DAT043 - föreläsning 8
DAT043 - föreläsning 8 Paket, generics, Java collections framework 2017-02-07 Paket och tillgänglighet Ovanför klasser finns en hierarkisk namespace med paket. Filer som inte deklareras i något paket finns
Tentamen Programmeringsteknik II och NV2 (alla varianter) 2008-12-10. Skriv bara på framsidan av varje papper.
Tentamen Programmeringsteknik II och NV2 (alla varianter) 2008-12-10 Skrivtid: 0800-1300 Inga hjälpmedel. Tänk på följande Maximal poäng är 40. För betygen 3 krävs 18 poäng. För betygen 4, 5 kommer något
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.
Tentamen Programmeringsteknik II 2014-0-27 Skrivtid: 0800 100 Tänk på följande Skriv läsligt! Använd inte rödpenna! Skriv bara på framsidan av varje papper. Börja alltid ny uppgift på nytt papper. Lägg
Datastrukturer, algoritmer och programkonstruktion (DVA104, VT 2015) Föreläsning 6
Datastrukturer, algoritmer och programkonstruktion (DVA104, VT 2015) Föreläsning 6? DAGENS AGENDA Komplexitet Ordobegreppet Komplexitetsklasser Loopar Datastrukturer Några nyttiga regler OBS! Idag jobbar
Föreläsning 10 Innehåll. Diskutera. Inordertraversering av binära sökträd. Binära sökträd Definition
Föreläsning Innehåll Diskutera Binära sökträd algoritmer för sökning, insättning och borttagning implementering effektivitet balanserade binära sökträd, AVL-träd Jämföra objekt interfacet Comparable Interfacet
Objektorienterad Programkonstruktion. Föreläsning 9 30 nov 2016
Objektorienterad Programkonstruktion Föreläsning 9 30 nov 2016 Collections Ett samlingsnamn på objekt som innehåller en samling av andra objekt Det finns många olika sorters Collections, t.ex listor, träd,
Kungl. Tekn. Högskolan Förel 1, bild 1 Föreläsning 1: Introduktion ffl Kursinnehåll ffl Javarepetition ffl Referenser ffl Nyckelordet static ffl Klass
Kungl. Tekn. Högskolan Förel 1, bild 1 Föreläsning 1: Introduktion ffl Kursinnehåll ffl Javarepetition ffl Referenser ffl Nyckelordet static ffl Klassen Mio ffl Särfall ffl Interface Kungl. Tekn. Högskolan
Föreläsning Datastrukturer (DAT036)
Föreläsning Datastrukturer (DAT036) Nils Anders Danielsson 2012-11-05 Repetition Förra gången: Listor, stackar, köer. Länkade listor, pekarjonglering. Idag: Cirkulära arrayer. Dynamiska arrayer. Amorterad
Föreläsning 3. Stack
Föreläsning 3 Stack Föreläsning 3 ADT Stack Stack JCF Tillämpning Utvärdera ett postfix uttryck Stack implementerad med en array Stack implementerad med en länkad lista Evaluate postfix expressions Läsanvisningar
TDDC30. Objektorienterad programmering i Java, datastrukturer och algoritmer. Föreläsning 8 Erik Nilsson, Institutionen för Datavetenskap, LiU
TDDC30 Objektorienterad programmering i Java, datastrukturer och algoritmer. Föreläsning 8 Erik Nilsson, Institutionen för Datavetenskap, LiU På denna föreläsning: Träd Traversering Insättning, borttagning
Outline. Objektorienterad Programmering (TDDC77) En frukt har ett namn. Man kan lägga en frukt i en korg... Hashing. Undantag. Ahmed Rezine.
Outline Objektorienterad Programmering (TDDC77) Föreläsning XIV: Undantag, Design Ahmed Rezine IDA, Linköpings Universitet Undantag Design Hösttermin 2017 En frukt har ett namn Man kan lägga en frukt i
Seminarium 13 Innehåll
Seminarium 13 Innehåll Prioritetsköer och heapar Prioritetsköer ADTn Klassen PriorityQueue i java.util Implementering med lista Heapar ADTn För implementering av prioritetskö För sortering Efter seminariet
Länkade strukturer. (del 2)
Länkade strukturer (del 2) Översikt Abstraktion Dataabstraktion Inkapsling Gränssnitt (Interface) Abstrakta datatyper (ADT) Programmering tillämpningar och datastrukturer 2 Abstraktion Procedurell abstraktion
ADT Prioritetskö. Föreläsning 13 Innehåll. Prioritetskö vs FIFO-kö. Prioritetskö Exempel på användning. Prioritetsköer och heapar
Föreläsning 1 Innehåll ADT Prioritetskö Prioritetsköer och heapar Prioritetsköer och heapar ADT prioritetskö Klassen PriorityQueue i java.util ar Implementering av prioritetskö med heap Sortering med hjälp
Föreläsning 7 Innehåll. Rekursion. Rekursiv problemlösning. Rekursiv problemlösning Mönster för rekursiv algoritm. Rekursion. Rekursivt tänkande:
Föreläsning 7 Innehåll Rekursion Rekursivt tänkande: Hur många år fyller du? Ett år mer än förra året! Rekursion Rekursiv problemlösning Binärsökning Generiska metoder Rekursiv problemlösning: Dela upp
ADT Kö. Seminarium 4 Köer och Stackar Innehåll. Operationer. ADT Stack. Definition. Definition
Seminarium 4 Köer och Stackar Innehåll ADT:erna Kö och Stack Definitioner Operationer Exempel på användning Givna klasser i Java Interfacet Queue Klassen Stack Klassen LinkedList Klassen PriorityQueue
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
Tentamen Programmeringsteknik II 2017-10-23 Skrivtid: 14:00 19:00 Inledning Skrivningen innehåller ett antal bilagor: Bilagan listsandtrees innehåller fyra klasser: Klassen List med några grundläggande
Lösningsförslag till tentamen Datastrukturer, DAT037,
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.
Föreläsning 13 Datastrukturer (DAT037)
Föreläsning 13 Datastrukturer (DAT037) Fredrik Lindblad 1 2016-12-14 1 Slides skapade av Nils Anders Danielsson har använts som utgångspunkt. Se http://www.cse.chalmers.se/edu/year/2015/course/dat037 Sammanfattning
Lösningsförslag. Programmeringsmetodik, KV: Java och OOP. 17 januari 2004
Lösningsförslag Programmeringsmetodik, KV: Java och OOP 17 januari 2004 Examinator: Johan Karlsson Skrivtid: 9-15 Hjälpmedel: En av följande böcker: Barnes & Kölling: Objects First With Java a practical
Trädstrukturer och grafer
Översikt Trädstrukturer och grafer Trädstrukturer Grundbegrepp Binära träd Sökning i träd Grafer Sökning i grafer Programmering tillämpningar och datastrukturer Varför olika datastrukturer? Olika datastrukturer
Objektorienterad Programmering (TDDC77)
Objektorienterad Programmering (TDDC77) Föreläsning XIV: Undantag, Design Ahmed Rezine IDA, Linköpings Universitet Hösttermin 2017 Outline Hashing Undantag Design Outline Hashing Undantag Design En frukt
Lösningsförslag till tentamen Datastrukturer, DAT037 (DAT036), Tiden det tar att utföra en iteration av loopen är oberoende av värdet på
Lösningsförslag till tentamen Datastrukturer, DAT037 (DAT036), 2017-01-11 1. Loopen upprepas n gånger. getat på en dynamisk array tar tiden O(1). member på ett AVL-träd av storlek n tar tiden O(log n).
Föreläsning 4. ADT Kö Kö JCF Kö implementerad med en cirkulär array Kö implementerad med en länkad lista
Föreläsning 4 Kö Föreläsning 4 ADT Kö Kö JCF Kö implementerad med en cirkulär array Kö implementerad med en länkad lista ADT Kö Grundprinciper: En kö fungerar som en kö. Man fyller på den längst bak och
F5: Debriefing OU2, repetition av listor, träd och hashtabeller. Carl Nettelblad
F5: Debriefing OU2, repetition av listor, träd och hashtabeller Carl Nettelblad 2017-04-24 Frågor Kommer nog inte att täcka 2 timmar Har ni frågor på OU3, något annat vi har tagit hittills på kursen, listor
Programmering för språkteknologer II, HT2011. Rum
Programmering för språkteknologer II, HT2011 evelina.andersson@lingfil.uu.se Rum 9-2035 http://stp.ling.uu.se/~evelina/uv/uv11/pst2/ Kursplan Mål Efter avslutad kurs skall studenten för att förtjäna betyget
Objektorienterad Programmering DAT043. Föreläsning 9 12/2-18 Moa Johansson (delvis baserat på Fredrik Lindblads material)
Objektorienterad Programmering DAT043 Föreläsning 9 12/2-18 Moa Johansson (delvis baserat på Fredrik Lindblads material) 1 Metoden clone() Skapa kopior av existerande objekt. Interface Cloneable Deep vs.
Idag. Exempel, version 2. Exempel, version 3. Ett lite större exempel
Idag Ett exempel Undantag Substitutierbarhet, subtyper, subklasser När val av metod beror av typerna hos två objekt Lite om överlagring Exempel, version 2 Notera: för samtliga figurer gäller: arean av
Föreläsning Datastrukturer (DAT036)
Föreläsning Datastrukturer (DAT036) Nils Anders Danielsson 2013-10-30 Repetition Analys av tidskomplexitet. Kostnadsmodeller. Asymptotisk komplexitet/notation. Dynamiska arrayer. Amorterad tidskomplexitet
Föreläsning 7. Träd och binära sökträd
Föreläsning 7 Träd och binära sökträd Föreläsning 7 Träd Binära träd Binärt sökträd som ADT Implementering av binärt sökträd Travestera binärt sökträd Sökning Insättning/borttagning Läsanvisningar och
Tentamen, EDA690 Algoritmer och Datastrukturer, Helsingborg
LUNDS TEKNISKA HÖGSKOLA 1(5) Institutionen för datavetenskap Tentamen, EDA690 Algoritmer och Datastrukturer, Helsingborg 2013 12 19, 8.00 13.00 Anvisningar: Denna tentamen består av 4 uppgifter. Preliminärt
Inlämningsuppgiften. Föreläsning 9 Innehåll. Träd. Datastrukturer i kursen
Föreläsning 9 Innehåll Inlämningsuppgiften De föreläsningar som inlämningsuppgiften bygger på är nu klara. Det är alltså dags att börja arbeta med inlämningsuppgiften. Träd, speciellt binära träd egenskaper
Programmering för språkteknologer II, HT2014. Rum
Programmering för språkteknologer II, HT2014 Avancerad programmering för språkteknologer, HT2014 evelina.andersson@lingfil.uu.se Rum 9-2035 http://stp.ling.uu.se/~evelina/uv/uv14/pst2/ Idag - Sökalgoritmer
Föreläsning 8 - del 2: Objektorienterad programmering - avancerat
Föreläsning 8 - del 2: Objektorienterad programmering - avancerat Johan Falkenjack johan.falkenjack@liu.se Linköpings universitet Sweden December 4, 2013 1 Innehåll Arv och andra viktiga begrepp Abstrakta
OOP Objekt-orienterad programmering
OOP F6:1 OOP Objekt-orienterad programmering Föreläsning 6 Mer om klasser och objekt Hantera många objekt ArrayList tostring() metoden this Vi vill ofta hantera många objekt i ett program: OOP F6:2 public
Tentamen Datastrukturer (DAT036)
Tentamen Datastrukturer (DAT036) Datum och tid för tentamen: 2012-08-24, 8:30 12:30. Ansvarig: Nils Anders Danielsson. Nås på 0700 620 602 eller anknytning 1680. Besöker tentamenssalarna ca 9:30 och ca
Datastrukturer, algoritmer och programkonstruktion (DVA104, HT 2014) Föreläsning 5
Datastrukturer, algoritmer och programkonstruktion (DVA104, HT 2014) Föreläsning 5? FORTSÄTTNING TRÄD RECAP (förra föreläsningen) RECAP (förra föreläsningen) Träd är icke-linjära datastrukturer som ofta
Lägg uppgifterna i ordning. Skriv uppgiftsnummer och din kod överst i högra hörnet på alla papper.
Tentamen Programmeringsteknik II 2016-05-30 Skrivtid: 1400 1900 Tänk på följande Skriv läsligt. Använd inte rödpenna. Skriv bara på framsidan av varje papper. Börja alltid ny uppgift på nytt papper. Lägg
Omtentamen för TDA540 Objektorienterad Programmering. Institutionen för Datavetenskap CTH HT-17, TDA540. Dag: , Tid:
Omtentamen för TDA540 Objektorienterad Programmering Institutionen för Datavetenskap CTH HT-17, TDA540 Dag: 2018-04-06, Tid: 14.00-18.00 Ansvarig: Examinator: Alex Gerdes Carlo A. Furia Förfrågningar:
Programmering för Språkteknologer II. Innehåll. Associativa datastrukturer. Associativa datastrukturer. Binär sökning.
Programmering för Språkteknologer II Markus Saers markus.saers@lingfil.uu.se Rum -040 stp.lingfil.uu.se/~markuss/ht0/pst Innehåll Associativa datastrukturer Hashtabeller Sökträd Implementationsdetaljer
Tentamen TEN1 HI
Tentamen TEN1 HI1029 2015-03-17 Skrivtid: 8.15-13.00 Hjälpmedel: Referensblad (utdelas), papper (tomma), penna Logga in med tentamenskontot ni får av skrivvakten. Det kommer att ta tid att logga in ha
LÖSNINGSFÖRSLAG Programmeringsteknik För Ing. - Java, 5p
UMEÅ UNIVERSITET Datavetenskap 010530 LÖSNINGSFÖRSLAG Programmeringsteknik För Ing. - Java, 5p Betygsgränser 3 21,5-27 4 27,5-33,5 5 34-43 Uppgift 1. (4p) Hitta de fel som finns i nedanstående klass (det
Det finns en referensbok (Java) hos vakten som du får gå fram och läsa men inte ta tillbaka till bänken.
Tentamen Programmeringsteknik I 2015-03-19 Skrivtid: 14:00 19:00 Hjälpmedel: Java-bok Tänk på följande Det finns en referensbok (Java) hos vakten som du får gå fram och läsa men inte ta tillbaka till bänken.
Föreläsning 13 Datastrukturer (DAT037)
Föreläsning 13 Datastrukturer (DAT037) Fredrik Lindblad 1 11 december 2017 1 Slides skapade av Nils Anders Danielsson har använts som utgångspunkt. Se http://www.cse.chalmers.se/edu/year/2015/course/dat037
EDAA20 Föreläsning Klassen ArrayList. Viktiga operationer på ArrayList. Generisk klass
EDAA20 Föreläsning 11-12 Klassen ArrayList Klassen ArrayList Skriva program som läser data från en textfil och skriver data till en textfil Repetition inför delmålskontroll 2 är en standardklass (i paketet