Übung 10: Dynamische Datenstrukturen und Rekursion

Ähnliche Dokumente
Übung Grundlagen der Programmierung WS 2008/09. Übung 04: Methoden. Abgabetermin: Prosabeschreibung Java-Programm.

Institut für Programmierung und Reaktive Systeme 17. Juli Programmieren II. Übungsklausur

Fortgeschrittene Programmiertechnik Klausur WS 2014/15 Angewandte Informatik Bachelor

Fortgeschrittene Programmiertechnik Klausur SS 2015 Angewandte Informatik Bachelor

// Objekt-Methoden: public void insert(int x) { next = new List(x,next); } public void delete() { if (next!= null) next = next.next; } public String

3 Dynamische Datenstrukturen

Abgabe: (vor 12 Uhr)

! 1. Rekursive Algorithmen.! 2. Rekursive (dynamische) Datenstrukturen. II.3.2 Rekursive Datenstrukturen - 1 -

16. Dezember 2004 Dr. M. Schneider, P. Ziewer

ALP II Dynamische Datenmengen

Einführung in die Programmierung für Wirtschaftsinformatik

1. Typen und Literale (6 Punkte) 2. Zuweisungen (6 = Punkte)

Kapitel 3: Datentyp Liste

Programmiertechnik II Klausur WS 15/16 Angewandte Informatik Bachelor

Institut für Programmierung und Reaktive Systeme 7. Juli Programmieren II. Übungsklausur

Musterlösungen zu Kapitel 17 aus H.Mössenböck: Sprechen Sie Java?

public static void replace(stringbuffer b) { for (int i = 0; i < b.length(); i++) { char replacechar; switch( b.charat(i) ) {

Fortgeschrittene Programmiertechnik Klausur WS 2014/15 Angewandte Informatik Bachelor

Schwerpunkte. Verkettete Listen. Verkettete Listen: 7. Verkettete Strukturen: Listen. Überblick und Grundprinzip. Vergleich: Arrays verkettete Listen

Übung Grundlagen der Programmierung. Übung 03: Schleifen. Testplan Testergebnisse

Technische Universität Braunschweig Institut für Programmierung und Reaktive Systeme

II.3.1 Rekursive Algorithmen - 1 -

class ListElement { int value; ListElement next; ListElement() { next=null; value=0;

Vorlesung Informatik 2 Algorithmen und Datenstrukturen. (07 - Skiplisten) Prof. Dr. Susanne Albers

Schlussendlich geben wir die Listen aus. Es kommt zu folgender Ausgabe:

12 Abstrakte Klassen, finale Klassen und Interfaces

Vorkurs Informatik Wintersemester 2015/2016. Programmtexte

Lösungen zum Übungsblatt 10: Entwicklung von Softwaresystemen I (WS 2003/04)

Praktische Informatik 1 Datenstrukturen

ALP II Dynamische Datenmengen Datenabstraktion (Teil 2)

Vorlesung Informatik 2 Algorithmen und Datenstrukturen

Kapitel 4: Datentyp Keller und Schlange

Technische Universität Braunschweig Institut für Programmierung und Reaktive Systeme

Übergang von funktionaler zu OOP. Algorithmen und Datenstrukturen II 1

CoMa 04. Java II. Paul Boeck. 7. Mai Humboldt Universität zu Berlin Institut für Mathematik. Paul Boeck CoMa 04 7.

Kapitel 12: Induktive

Übung Grundlagen der Programmierung. Übung 05: Arrays. Abgabetermin: xx.xx.xxxx. Java-Programm Testplan Testergebnisse

Aufgabe 1 (Programmanalyse, Punkte)

Hochschule Augsburg, Fakultät für Informatik Name:... Prüfung "Programmieren 1", IN1bac, WS 10/11 Seite 1 von 6

ADT: Verkettete Listen

3. Übungsbesprechung Programmkonstruktion

Geordnete Binärbäume

Informatik II Prüfungsvorbereitungskurs

Einführung in die Informatik: Programmierung und Software-Entwicklung, WS 11/12 1. Kapitel 11. Listen. Listen

Institut für Informatik

3. Übungsblatt zu Algorithmen I im SoSe 2017

Interfaces und Generics

Einführung in die Informatik: Programmierung und Software-Entwicklung, WS 16/17. Kapitel 13. Listen. Listen 1

Einführung Datentypen Verzweigung Schleifen Funktionen Dynamische Datenstrukturen. Java Crashkurs. Kim-Manuel Klein

Übung Algorithmen und Datenstrukturen

Stapel (Stack, Keller)

Aufgaben NF 11; Seite 1

Einführung in die Informatik: Programmierung und Software-Entwicklung, WS 16/17. Kapitel 14. Bäume. Bäume 1

Lösungsvorschläge. zu den Aufgaben im Kapitel 4

12. Dynamische Datenstrukturen

Programmieren 2 Übung Semesterwoche 2

Einführung in die Programmierung Vorlesungsprüfung

Tutoraufgabe 1 (2 3 4 Bäume):

! 1. Unterklassen und Vererbung! 2. Abstrakte Klassen und Interfaces! 3. Modularität und Pakete. II.4.2 Abstrakte Klassen und Interfaces - 1 -

Probeklausur Informatik 2 Sommersemester 2013

Allgemeine Hinweise:

Klausur Sommersemester 2012 Datenstrukturen und Algorithmen 24. September 2012

Algorithmen und Datenstrukturen

Übergang von funktionaler zu OOP. Algorithmen und Datenstrukturen II 1

Programmieren 2 Java Überblick

Gliederung. 5. Compiler. 6. Sortieren und Suchen. 7. Graphen

Programmierkurs Java

Innere Klassen. Innere Klassen. Page 1. Lernziele: innere Klassen, statische geschachtelte Klassen, anonyme Klassen.

13. Bäume: effektives Suchen und Sortieren

II. Grundlagen der Programmierung. 9. Datenstrukturen. Daten zusammenfassen. In Java (Forts.): In Java:

1.2 Attribute und Methoden Aufbau einer Java-Klasse:

Programmierkurs Java

Bäume. Informatik B - Objektorientierte Programmierung in Java. Vorlesung 10: Collections 4. Inhalt. Bäume. Einführung. Bäume.

Bäume. Text. Prof. Dr. Margarita Esponda SS 2012 O4 O5 O6 O ALP2-Vorlesung, M. Esponda

Große Übung Praktische Informatik 1

Übung 4: Die generische Klasse AvlBaum in Java 1

Algorithmen und Datenstrukturen. Übersicht. Interfaces und Generics. InsertionSort für Punkte. InsertionSort für Punkte

Praktikum zu Einführung in die Informatik für LogWings und WiMas Wintersemester 2013/14

TECHNISCHE UNIVERSITÄT MÜNCHEN FAKULTÄT FÜR INFORMATIK

Stacks, Queues & Bags. Datenstrukturen. Pushdown/Popup Stack. Ferd van Odenhoven. 19. September 2012

Test zu Grundlagen der Programmierung Leitung: Michael Hahsler. 21. Juni 2004

6. Verkettete Strukturen: Listen

Prof. H. Herbstreith Fachbereich Informatik. Leistungsnachweis. Informatik 1 WS 2001/2002

EINFÜHRUNG IN DIE PROGRAMMIERUNG

Grundlagen der Programmierung Prof. H. Mössenböck. 14. Schrittweise Verfeinerung

Verkettete Datenstrukturen: Listen

Klausur zur Informatik A WS 2001/2002 Name: Korrektor: Punkte: a) Zeichnen Sie zu der nachstehenden Syntax in EBNF die passenden Syntaxdiagramme.

Musterlösung Stand: 5. Februar 2009

Übungslösungen. 1. Übung

Objektorientierte Programmierung

Programmieren in C. Rekursive Strukturen. Prof. Dr. Nikolaus Wulff

PIWIN 1 Übung Blatt 5

1 Programmierfehler und ihre Behebung

Schein-/Bachelorklausur Teil 2 am Zulassung: Mindestens 14 Punkte in Teilklausur 1 und 50% der Übungspunkte aus dem 2. Übungsblock.

EINFÜHRUNG IN DIE PROGRAMMIERUNG

Aufgabenblatt: Arrays

Einführung Elementare Datenstrukturen. Der Konstruktor muß den Listenkopf head erzeugen. Der Vorgänger und Nachfolger von head ist head selbst.

public class SternchenRechteckGefuellt {

Einführung in die Informatik: Programmierung und Software-Entwicklung, WS 11/12. Kapitel 13. Bäume. Bäume

Informatik II Vorlesung am D-BAUG der ETH Zürich

Transkript:

Übung 10: Dynamische Datenstrukturen und Rekursion Abgabetermin: TT.MM.JJJJ Name: Matrikelnummer: Gruppe: G1 (Prähofer) G2 (Wolfinger) G3 (Wolfinger) Aufgabe Punkte gelöst abzugeben schriftlich abzugeben elektronisch Aufgabe 09.X 12 Java-Programm Java-Programm Testergebnisse Korr. Pkte Aufgabe 10.x: Verkettete lineare Liste Implementieren Sie eine einfach verkettete lineare Liste in der Klasse List. Verwenden Sie dabei die Klasse Node für die Knoten der Liste. class List { Node head; public List() { class Node { int val; Node next; public Node(int val) { Vervollständigen Sie die beiden Konstruktoren und implementieren Sie in der Klasse List folgende Methoden: void prepend(int val) fügt den Wert val vorne in die Liste ein void append(int val) fügt den Wert val hinten in die Liste ein boolean issorted() stellt fest, ob die Werte der Knoten der Liste aufsteigend sortiert sind void insert(int val) fügt den Wert val in eine sortierte Liste an der richtigen Stelle ein, sodass die neue Liste wieder sortiert ist und String tostring() liefert eine Zeichenkette mit den Werten der Knoten, durch Beistriche voneinander getrennt. Testen Sie Ihre Methoden, auch für Fehlerfälle. Lösungsidee Nachstehende Abbildung zeigt in a) wie die Objektstruktur einer Liste mit zwei Knoten aussieht, und in b) das Klassendiagramm.

Java-Programm 1 class Node { 2 int val; 3 Node next; 4 public Node(int val) { 5 this.val = val; 6 7 8 9 public class List { 10 Node head; 11 public List() { 12 head = null; 13 14 public void prepend(int val) { 15 Node n = new Node(val); 16 n.next = head; 17 head = n; 18 19 public String tostring() { 20 StringBuffer b = new StringBuffer(); 21 Node p = head; 22 while(p!= null) { 23 b.append(','); 24 b.append(p.val); 25 p = p.next; 26 27 b.delete(0, 1); 28 return b.tostring(); 29 30 public void append(int val) { 31 Node n = new Node(val); 32 if(head == null) { 33 head = n; 34 else { 35 Node p = head; 36 while(p.next!= null) 37 p = p.next; 38 p.next = n; 39 40 41 public boolean issorted() { 42 Node p = head; 43 while(p!= null) { 44 if(p.next!= null && p.val > p.next.val) 45 return false; 46 p = p.next; 47 48 return true; 49 50 public void insert(int val) { 51 Node n = new Node(val); 52 Node p = head, prev = null; 53 while(p!= null && p.val < n.val) { 54 prev = p; 55 p = p.next; 56 57 if(prev == null) { 58 head = n; 59 else { 60 prev.next = n; 61 62 n.next = p; 63 64 public static void main(string[] args) { 65 List 66 67 68 Out.println(l); 69 Out.println(l.isSorted()); 70 71 72 73 l.append(2); 74 Out.println(l); 75 Out.println(l.isSorted()); 76 77 78 l.append(2);

79 80 Out.println(l); 81 Out.println(l.isSorted()); 82 83 84 l.insert(2); 85 l.insert(1); 86 l.insert(3); 87 l.insert(0); 88 Out.println(l); 89 Out.println(l.isSorted()); 90 91 Testspezifikation: Methode prepend: o Mit nicht-leerer Liste Methode append: o Mit Liste mit einem Element o Mit Liste mit vielen Elementen Methode sorted: => true o Mit Liste mit einem Element => true o Mit sortierter Liste mit zwei Elementen => true o Mit unsortierte Liste mit zwei Elementen => false o Mit sortierter Liste mit mehreren Elementen => true o Mit unsortierte Liste mit mehreren Elementen => false Methode insert: o Einfügen in leere Liste o Einfügen in Liste mit 1 Element am Anfang o Einfügen in Lsite mit 1 Element am Ende o Einfugen in Liste mit mehreren Elementen am Anfang o Einfugen in Liste mit mehreren Elementen am Ende o Einfugen in Liste mit mehreren Elementen in der Mitte Methode tostring o Mit Liste mit einem Element o Mit Liste mit vielen Elementen Testprogramm: public class ListTest { public static void main(string[] args) { List l; Out.println("-------- Test Methode tostring ---------------"); Out.println("Leere Liste []: " + l.tostring()); // Mit Liste mit einem Element Out.println("Leere Liste [3]: " + l.tostring()); // Mit Liste mit mehreren Elementen l.prepend(0); // Methode prepend: Out.println("-------- Test Methode prepend ---------------");

Out.println("Liste [1]: " + l.tostring()); // Mit nicht-leerer Liste Out.println("Liste [2, 1]: " + l.tostring()); Out.println("Liste [3, 2, 1]: " + l.tostring()); // Methode append: Out.println("-------- Test Methode append ---------------"); Out.println("Liste [1]: " + l.tostring()); // Mit nicht-leerer Liste l.append(2); Out.println("Liste [1, 2]: " + l.tostring()); Out.println("Liste [1, 2, 3]: " + l.tostring()); l.append(4); l.append(5); l.append(6); Out.println("Liste [1, 2, 3, 4, 5, 6]: " + l.tostring()); // Methode sorted Out.println("-------- Test Methode sorted ---------------"); => true // Mit Liste mit einem Element => true // Mit sortierter Liste mit zwei Elementen => true l.append(2); // Mit sortierter Liste mit mehreren Elementen => true l.insert(2); // Mit unsortierte Liste mit zwei Elementen => false // Mit unsortierte Liste mit mehreren Elementen => false // Methode insert Out.println("-------- Test Methode insert ---------------"); // Einfügen in leere Liste l.insert(3); Out.println("Liste [3]: " + l.tostring()); // Einfügen in Liste mit 1 Element am Anfang l.insert(1);

Out.println("Liste [1, 3]: " + l.tostring()); // Einfügen in Lsite mit 1 Element am Ende l.insert(5); Out.println("Liste [1, 3, 5]: " + l.tostring()); // Einfugen in Liste mit mehreren Elementen am Anfang l.insert(0); Out.println("Liste [0, 1, 3, 5]: " + l.tostring()); // Einfugen in Liste mit mehreren Elementen in der Mitte l.insert(2); Out.println("Liste [0, 1, 2, 3, 5]: " + l.tostring()); l.insert(4); Out.println("Liste [0, 1, 2, 3, 4, 5]: " + l.tostring()); // Einfugen in Liste mit mehreren Elementen am Ende l.insert(6); Out.println("Liste [0, 1, 2, 3, 4, 5, 6]: " + l.tostring()); // main Testergebnis: -------- Test Methode tostring --------------- Leere Liste []: [] Leere Liste [3]: [3] Leere Liste [2, 3]: [2, 3] Leere Liste [2, 3]: [1, 2, 3] Leere Liste [2, 3]: [0, 1, 2, 3] -------- Test Methode prepend --------------- Liste [1]: [1, 0, 1, 2, 3] Liste [2, 1]: [2, 1, 0, 1, 2, 3] Liste [3, 2, 1]: [3, 2, 1, 0, 1, 2, 3] -------- Test Methode append --------------- Liste [1]: [1] Liste [1, 2]: [1, 2] Liste [1, 2, 3]: [1, 2, 3] Liste [1, 2, 3, 4, 5, 6]: [1, 2, 3, 4, 5, 6] -------- Test Methode sorted --------------- Liste [] sorted = true Liste [1] sorted = true Liste [1, 2] sorted = true Liste [1, 2, 3] sorted = true Liste [1, 2, 3, 3] sorted = true Liste [1, 2, 2, 3, 3] sorted = true Liste [2, 1] sorted = false Liste [3, 2, 1] sorted = false Liste [3, 3, 2, 1] sorted = false Liste [1, 2, 1] sorted = false -------- Test Methode insert --------------- Liste [3]: [3] Liste [1, 3]: [1, 3] Liste [1, 3, 5]: [1, 3, 5] Liste [0, 1, 3, 5]: [0, 1, 3, 5] Liste [0, 1, 2, 3, 5]: [0, 1, 2, 3, 5] Liste [0, 1, 2, 3, 4, 5]: [0, 1, 2, 3, 4, 5] Liste [0, 1, 2, 3, 4, 5, 6]: [0, 1, 2, 3, 4, 5, 6]