Algorithmen und Datenstrukturen Übungsmodul 6 Dr. W. Narzt u. Dr. A. Stritzinger Institut für Wirtschaftsinformatik- Software Engineering JKU Linz

Verbund-Datentypen als Werte Verbund-Variable: Typ – Name – Wert – Adresse Jana Speicher Adresse Wert type Pair = { int a int b } Pair p p.a = 10 p.b = 13 100 104 108 112 10 13 .. Name = p Typ = Pair Adresse = 100 Adresse = 100 Wert = 10 p a b 13 10 Adresse = 104 Wert = 13

Referenzdatentypen Jana Speicher Adresse Wert Warum Referenzvariablen? reftype RefPair = { int a int b } RefPair p P = new RefPair p.a = 10 p.b = 13 100 104 108 112 116 120 .. 10 13 Name = p Typ = RefPair Adresse = 100 Wert = 112 Adresse = 112 Wert = 10 Adresse = 116 Wert = 13 p a b 13 10 a b 13 10 Warum Referenzvariablen? zur Laufzeit kann (beliebig viel) Speicherplatz für neue Daten belegt werden Strukturierung der Daten

Vergleich Referenz/Verbund-Datentypen I Wert-Variable  Referenzvariable  Deklaration type Person = { char[] firstName, lastName } reftype RefPerson = { char[] firstName, lastName } Erzeugen von Datenobjekten Person student Objekt wird bei Deklaration bereits erzeugt; Wert undefiniert! RefPerson refStudent Wert von student: Referenz auf ein Objekt Student; noch nicht initialisiert! refStudent = new RefPerson erst jetzt ist ein Objekt des Typs RefPerson erzeugt. Wert ist noch nicht definiert

Vergleich Referenz/Verbund-Datentypen II Wert-Variable  Referenzvariable  Zugriff auf Elemente student.firstName = "Hugo" refStudent^.firstName = "Hugo" oder refStudent.firstName = "Hugo" Spezieller Referenzwert null - refStudent = null Löschen von Datenobjekten delete refStudent jetzt gilt: refStudent == null Werden beim Verlassen des Algorithmus automatisch aus dem Speicher entfernt

Vergleich Referenz/Verbund-Datentypen III Wert-Variable  Referenzvariable  Zuweisung RefPerson hugo, franz hugo = new RefPerson hugo^.firstname = "Hugo" hugo^.lastname = "Berger" franz = hugo Achtung: Zuweisung der Referenz! Person hugo, franz hugo.firstname = "Hugo" hugo.lastname = "Berger" franz = hugo Vergleich RefPerson a,b,c a = new RefPerson, b = …; c =... a.firstName = "Hugo" a.lastName = "Berger" b.firstName = "Hugo" b.lastName = "Berger" c=a if (a == b) {...} //Gleichheit false! if (a == c) {...} //Identität true! Person a,b a.firstName = "Hugo" a.lastName = "Berger" b.firstName = "Hugo" b.lastName = "Berger"   if (a == b) {...} // true

Vergleich Referenz/Verbund-Datentypen IV Wert-Variable  Referenzvariable  Verwendung als Eingangsparameter g(RefPerson p) { p.firstName = "nix" } Kopie des Werts = Referenz wird übergeben !! f(Person p) { p.firstName = "nix" } Kopie des Werts = Datenobjekt selbst wird übergeben Verwendung als Übergangsparameter f(Person p) { Person a a.firstName = "franz" a.lastName ="Huber" p = a } g(RefPerson p) { RefPerson b; b = new Refperson b.firstName = "franz" b.lastName = "Huber" p = b } Referenz p wird verändert!

Verkettete Liste Idee: Liste als Folge von Datenelementen. Jedes Element enthält einen Verweis auf das nachfolgende Element. Liste kann also beliebig lang werden. Rekursiver Datentyp: enthält Referenzvariablen vom selben Typ wie er selbst ist. (Nur bei Referenztypen möglich!) Datentyp für Listenelement: reftype Node = { int value Node next }

Verkettete Liste als ADT //Verwendung useList() { List myList myList.init() .... myList.append(10) } type List = { reftype Node = { int value Node next } Node first init() { first = null } append(int a) { ... } } myList first myList first value: 10 next:

Liste durchlaufen (Bsp. Ausgabe) Von vorne nach hinten printList() { Node n = first while (n != null) writeln(n^.value) n = n^.next } Von hinten nach vorne printList() { Node last = null while (first != last) Node n = first while (n^.next != last) n = n^.next } writeln(n^.value) last = n

Elemente vorne einfügen insertFirst(int a) { Node n n = new Node // neues Element erzeugen n^.value = a // und initialisieren n^.next = first // Element vor das erste Element „einhängen“ first = n // neues Element ist ab nun das erste Element } Bsp: myList.insertFirst( 199) myList.first value: 18 next: value: 13 next: value: 199 next: n

Elemente hinten anhängen appendLast(int a) { Node n // neuen Knoten erzeugen und initialisieren n = new Node n^.value = a; n^.next = null if (first == null) // erstes Element wird eingefügt { first = n } else // Ende der Liste suchen { Node cur = first while (cur^.next != null) { cur = cur^.next } // cur zeigt auf das letzte Element in der Liste (cur.next == null) cur.next = n } } Bsp: myList.appendLast(199) myList.first value: 18 next: value: 13 n value: 199 cur

Liste vollständig löschen delete() { while (first != null) { Node next = first^.next // Referenz auf das nächste Element delete first // erstes Element der Liste löschen first = next // neues erstes Element der Liste } // first ist null }

Element sortiert einfügen insertSorted(int a) { Node n, cur, prev n = new Node n^.value = a cur = first // Einfügeposition suchen prev = null while ((cur != null) && (cur^.value < a)) { prev = cur cur = cur^.next } // prev zeigt auf Element vor der Einfügeposition if (prev != null) // Einfügen in der Mitte oder am Ende? { prev^.next = n //Mitte: cur != null, Ende: cur == null n^.next = cur } else // Einfügen am Beginn, oder die Liste ist leer { first = n n^.next = cur // leere Liste: cur == null }

Zirkuläre Liste mit Sentinel Sonderfälle reduzieren Liste enthält immer ein Element (Sentinel) Letzte Element verweist auf das erste Element der Liste Datentyp und Initialisierung: type List = { reftype Node = { int value Node next } Node sentinel init() { sentinel = new Node sentinel ^.next = sentinel sentinel ^.value = 0 // Wert irrelevant! } value: 0 next: sentinel

Zirkuläre Liste mit Sentinel Sortiertes einfügen: insert( int a) { Node n, cur, prev n = new Node n^.value = a cur = sentinel ^.next prev = sentinel while ((cur != sentinel) && (cur^.value < a)) { prev = cur cur = cur^.next } n^.next = cur prev^.next = n } beginne die Suche mit dem "1." Element mit gültigen Wert cur zeigt auf das Element hinter Einfügeposition (falls am Ende der Liste einzufügen ist, auf sentinel.) prev zeigt auf das Element vor der Einfügeposition (falls am Beginn der Liste einzufügen ist, auf sentinel).

Doppelt verkettete Liste myList type List = { reftype Node = { int value Node next Node prev } Node first Node last init() { first = null last = null } append(int a) { ... } } first last myList first value: 10 next: prev last myList first value: 10 next: prev value: 13 next: prev last

Löschen aus einer doppelt verketteten Liste f l Fall 1: Normalfall n^.prev^.next = n^.next n^.next^.prev = n^.prev Fall 2: Löschen am Anfang first = n^.next n^.next^.prev = null (n^.next^.prev = n^.prev) Fall 3: Löschen am Ende last = n^.prev n^.prev^.next = null (n^.prev^.next = n^.next) Fall 4: Nur 1 Element first = null last = null (first = n^.next) (last = n^.prev) n f l n f l n f l n

Löschen aus einer doppelt verketteten Liste delete ( int a) { // element suchen Node n = first while ((n != null) && (n^.value != a)) n = n^.next } // element gefunden? if (n != null) if (n == first) first = n^.next if (n == last) last = n^.prev if (n != first) n^.prev^.next = n^.next if (n != last) n^.next^.prev = n^.prev delete n