Lektion 7 Læsestof: Kopier fra Caranno Opsamling: Kompleksitet, Dataabstraktion/ADT Kædede lister: Principper C#-eksempel Java-eksempel LinkedList i .NET Træer: Især binære søgetræer I .NET 2 .Generics: SortedList Maps: HashMap TreeMap I .NET 2 .Generics: IDictionary Dictionary SortedDictionary Se: http://msdn.microsoft.com/en-us/library/system.collections.generic(VS.80).aspx

Kompleksitet Formålet med kompleksitetsteori er at undersøge en metodes (eller algoritmes) tids- og/eller pladsforbrug Normalt er man interesseret i worst-case (lettere at undersøge) grove vurderinger En metodes tidsforbrug angives vha. store-O: O(f(n)) n er størrelsen af input, f er en funktion, som angiver algoritmens effektivitet som funktion af n, fx log(n). store O: er asymptotisk (kun for tilpas store værdier af n) store O ser kun på mest betydende led store O: se bort fra konstanter

Forskellige kompleksiteter

Datastrukturer - ADT En datastruktur er en systematisk måde at organisere en mængde af data på. Array – statisk Kædet liste – dynamisk Træstruktur – oftest dynamisk Datastrukturer har brug for en række algoritmer til indsættelse, sletning, søgning af data Den samme mængde data kan ofte repræsenteres af forskellige datastrukturer

Abstrakte datatyper (ADT) En ADT er karakteriseret ved: Værdimængde Operationer Som før, bortset fra at datarepræsentationen nu er private. Dvs. vi kan kun tilgå data gennem de tilknyttede operationer (dvs. den kaldende kode er løst koblet til datarepræsentationen). En ADT skal have en tilhørende specifikation, dvs. en præcis beskrivelse af værdimængde og operationer. Implementeres uden at kende brugen – bruges uden at kende implementationsdetaljer – en kontrakt definerer interfacet. Indkapsler ofte en datastruktur

Figure 3.7 ADT operations provide access to a data structure Realisering: DS+alg. ADT: spec interface class

Opgave fra sidst: Løsning Specificér en ADT: deque ( en kø med to ender: på engelsk: double-ended queue, eller "deque" - udtales "dæk"). En deque har følgende operationer: public interface IDeque { void InsertFirst(Object e); void InsertLast(Object e); Object RemoveFirst(); Object RemoveLast(); bool IsEmpty(); } Skriv pre- og post-betingelser, som præcist specificerer ADT’en. (Overvej fordele og ulemper ved forskellige datastrukturer (array eller kædede) til implementering af) . Skriv en klasse, som implementerer dit interface. Skriv et testprogram. Lav en typesikker version.

Kædede lister (LinkedList) En kædet liste er en data-struktur bestående af en mængde af knuder til opbevaring af en ordnet mængde af elementer. Hver knude indeholder et dataelement og et link til næste knude (evt. null) Selve listen har et head som er et link til første knude (null, hvis listen er tom) En kædet liste er dynamisk i modsætning til array Elementer kan kun tilgås sekventielt i modsætning til array

Figure 4.1 a) A linked list of integers; b) insertion; c) deletion

Erklæring af knude i kædet liste private class Node { private object val; private Node next; public Node(object v, Node n) { val= v; next= n; } public object Val { get{return val;} set{val= value;} public Node Next { get{return next;} set{next= value;} Erklæring af knude i kædet liste Værdien i knuden Reference til næste knude (evt. null)

Erklæring af selve listen public class LinkedList{ private class Node //…. } Node head,tail; int n;//number of elements public LinkedList() head= null; tail= null; n= 0; //More operations

Operationer på listen: Tilføj i sidst: public void Add(object o) {//Add node at the rear of the list Node tmp = new Node(o, null); if (Count == 0)//list is empty head = tmp; else tail.Next = tmp; tail = tmp; n++; }

Tilføj i først: public void AddFront(object o) { Node tmp = new Node(o, null); if (Count == 0)//list is empty tail = tmp; else tmp.Next = head; head = tmp; n++; }

Sweeping: public void Sweep() {// Node p = head; while (p != null) { // Do something to p.Val for instance print: System.Console.WriteLine(p.Val); p = p.Next; //get next element }

get(i) public object GetElementAt(int pos) { //pre: 0<=pos && pos<Count //post: returns value of node number pos Node p = head; for(int i= 0; i<pos; i++) p = p.Next; return p.Val; }

Searching public int FindPos(object o) { //Returns the position of o in the list (counting from 0). //If o is not contained, -1 is return. bool found = false; int i = 0; Node p = head; while (!found && p != null) { if (p.Val.Equals(o)) found = true; else { p = p.Next; i++; } if (found) return i; else return -1;

Dynamisk vs. statisk datastruktur Lister (sekvenser) implementeret vha. array eller ArrayList: en fast (statisk) størrelse (pladsspild) kan evt. vokse (ArrayList), men dette er meget dyrt i køretid (O(n)) har direkte access til elementer udfra index (O(1)) Kædet implementation: bruger kun den nødvendige plads - vokser/aftager efter behov access via traversering (dyrt: O(n)) Se Java-eksempel: lists.zip

Kædede lister - varianter Kædet liste med tail

Kædede lister - varianter Kædet liste med dummy head Forenkler koden (indsættelse og sletning i starten er ikke specialtilfælde)

Kædede lister - varianter Cirkulær kædet liste

Kædede lister - varianter Dobbeltkædet liste – kan navigere begge veje (LinkedList<T> i .Generics)

Dobbelt kædet: Lidt mere komplicerede operationer...

Hele svineriet…. (LinkedList<T>) Opgave: Implementér IDeque vha. af LinkedList<object>

Træer - eksempler: a) Organisationsstruktur b) Stamtræ

Terminologi Generelle træer (stamtavle, klassehierarki, mmm.): blad/ekstern knude/terminal rod intern knude søskende, børn, forældre, forfædre, efterkommere undertræer/subtræer knudes dybde/højde = antal forfædre træets højde/dybde = max højde/dybde for alle blade

Binære træer Et binært træ kan defineres rekursivt, som værende enten tomt eller består af en rod samt et højre og et venstre undertræ Bemærk, i modsætning til generelle træer undertræer er ordnede (venstre, højre) træet kan være tomt

Eksempel: udtrykstræer

Binære træer kan være balancerede, skæve eller halvskæve….

…fulde,...

…eller komplette

Datastrukturer til repræsentation af binære træer Kædet struktur Som vi kender det fra den kædede liste, blot indeholder hver knude to child-referencer samt en forældrereference. Head (her kaldet root) har fat i roden.

Operationer Traversering kan foretages inorder (venstre, rod, højre) preorder (rod, venstre, højre) postorder (venstre, højre, rod) rekursivt (inorder) traverser venstre sub-træ gør noget (f.eks. visning) ved roden traverser højre sub-træ

Figure 10.9 Traversals of a binary tree: a) preorder; b) inorder; c) postorder

Søgetræer - især de binære Nøglebaseret container: søgetræsegenskaben: værdien i en hver indre knude er større end værdien i venstre undertræ værdien i en hver indre knude er mindre end værdien i højre undertræ undertræerne er selv binære søgetræer

Binært søgetræ

Inddata i sorteret orden!!! inOrder-gennemløb giver sorteret orden Balanceproblemer: Inddata i sorteret orden!!! inOrder-gennemløb giver sorteret orden

Effektivitet insert O(log n) / O(n) retrieve delete Afhænger alle af træets dybde Hvis insert og delete kommer nogenlunde jævnt vil træet efterhånden gro skævt O(log n) / O(n) Kode Kan holdes balancerede. Er kompliceret og giver O(n) indsættelse og sletning I .NET 2 Generics: SortList

Generelle træer Består af en enkelt knude eller en rodknude med et vilkårligt antal subtræer Kan ikke implementeres på samme måde som binære træer, da antallet af subtræer kan variere meget Fx:

Træstruktur – objektmodel - composite Træelement - abstrakt træ Blad Træ 0..*

Balancerede søgetræer Køber tid for plads: i værste fald bruges ekstra lager O(n); tilgengæld: retrieve, insert og delete alle O(log n) - også wc. Princip: En knude kan indeholde flere nøgler (n>1) og har også flere børn (n+1>2) En knude skal altid være mindst halvfuld (n/2) Indsættelse og sletning udføres, så træet altid er balanceret

2-3-træer (n=2)

Retrieve Søgning efter samme princip som binære søgetræer: søg i roden hvis ikke fundet, så søg rekursivt i det rigtige undertræ tidsforbrug proportionalt med træets dybde, træet er balanceret, dvs. O(log n)

Indsættelse Indsættelsesalgoritmen skal sikre, at disse egenskaber bevares: søg ned i træet til den rigtige plads hvis der er plads i bladknuden, så sæt ind ellers split og ryk midterværdien op, hvis der ikke er plads i parent, så gentag rekursivt, evt. til roden, hvor der dannes en ny rod tidsforbrug afhænger af træets dybde (søgning ned gennem træet + en tur op under rebalancering) dvs. O(log n)

Sletning Ligesom indsættelse - bare lige omvendt:-) find knuden, hvor værdien er hvis det ikke er et blad, så byt med inorder-efterfølgeren (som altid er et blad - hvorfor?) hvis der nu er for få værdier i bladet, så slå sammen med en søskende og træk en værdi ned, hvis der nu er for få værdier i parent, så fortsæt rekursivt mod roden hvis roden bliver tom, så slet den igen: ned og op gennem træet: O(log n)

Balancerede søgetræer Varianter: 2-3-træer 2-3-4-træer Rød-Sort-træer AVL-træer Splay-træer…. Anvendes bla. til realiseringer af ADTTable I .NET 2 .Generics: SortedDictionary<T>

ADTTable/Map/Dictionary value key Lagrer par: (key, value) key er entydig (understøtter i hvert fald equals) value kan være hvad som helst (et vilkårligt objekt) Interessante operationer: retrieve (get/find) insert (add/put) delete (remove) traverse (evt. i nøgleorden) (evt. også isEmpty, size mv.) I .NET 2 Generics: IDictionary<T>

Gælder altid for balanceret søgetræ Sammenligning af simple implementationer (array, linked list, sort/unsort, binært søgetræ) Kun hvis vi er heldige SortedDictionary i .NET: O(log n) O(logn) O(logn) O(n) Gælder altid for balanceret søgetræ

Alternativ implementering af ADTTable: Hashing Det drejer sig om at sende vilkårlige nøgler ind i et array hvor vi kan finde dem igen. Hvis nøglerne er en heltalsværdier startende i 0, er problemstillingen simpel. Hvis ikke sendes de gennem en såkaldt hashfunktion der afbilder mængden af nøgleværdier på mængden af arrayindekser. To nøgler der giver samme værdi vil kollidere.

Kollisionshåndtering Primtalsstørrelse på arrayet mindsker antallet af kollisioner: Ex h(k) = k MOD n: Hash 200, 205, 210, ….., 600 ind i et array af størrelse 100 giver 3 kollisioner, hvorimod et array af størrelse 101 giver 0. Hash-funktioner er en hel videnskab (matematisk) for sig.

Kollisionshåndtering Probing: Lineær (h(x)+1, +2, +3, +4,…) Kvadratisk (h(x)+1, +2, +4, +8,…) Double hashing

Chaining Lade arrayet indeholde lister/maps af elementer i stedet for blot elementer:

Effektivitet af hashing Værste fald (max antal kollisioner): retrieve, insert, delete alle O(n) Gennemsnitligt antal kollisioner afhænger af load factor α = antal tabelelementer/tabelstørrelse men ikke af n! typisk (lineær probing): antal kollisioneravg = 1/(1 - α) Ex.: 80% af tabellen er i brug: α = 0.8: 1/(1-0.8) = 5 kollisioner i gennemsnit.

Når hashing er ineffektiv Traversering i nøgleorden Mindste/største nøgle Range-search (alle nøgler mellem high og low) På disk giver hashing større fordele i forhold til balancerede træer. Ofte anvender DBMS’er både hashindex og B+-træer i kombination Java-eksempel

Opsamling Abstrakte datatyper: lister/sekvenser stak kø Table/Map/Dictionary .NET-specifik: Collections.Generics IDictionary IList Algoritmer: søgning sweep sortering del&hersk rekursion Datastrukturer: statisk/dynamisk array kædet liste træer: søgetræer balancerede hashing

Opsamling - .NET 2 Generics (key,value) -par ICollection<T> IList<T> LinkedList<T> IDictionary<TKey, TValue> List<T> SortedDictionary<TKey, TValue> Dictionary <TKey, TValue> Indekserbare Array-baseret Balanceret søgetræ Hashtabel

Opgaver Masser af læsestof Undersøg egenskaber og muligheder i Collections.Generic. Brug: http://msdn.microsoft.com/en-us/library/system.collections.generic(VS.80).aspx Lav lidt ”pointer-kode”: linkedList.htm