/* 
 * File:   main.cpp
 * Author: maximilian.krieg
 *
 * Created on 19. rechtsuni 2012, 14:36
 */

#include 
#include 
#include 
using namespace std;

/*
 * 
 */
void ausgabe(vectorvi) {
    for (int i = 0; i < vi.size(); i++) {
	cout << vi[i];
    }
    cout << endl;
}

void quicksort(vector& vi, int ui, int oi) {
    // Start bei UI und Element links von OI
    // OI == Pivot-Element
    int links = ui;
    int rechts = oi - 1;
    int pivot = oi;

    // Solange die Zeiger noch auf ihrer Seite sind
    while (links <= rechts) {

	// Laufen bis Element gefunden, das kleiner als Pivot
	while (vi[rechts] > vi[pivot]) 
	{rechts--;}

	// Laufen bis Element gefunden, das größer als Pivot
	while (vi[links] < vi[pivot]) 
	{links++;}

	// Tausch der beiden Elemente an dem die Zeiger stehen geblieben sind
	// Nur solange die Zeiger noch nicht die Teilbäume gewechselt haben
	if (links <= rechts) {
	    // Tauschen
	    int tmp = vi[links];
	    vi[links] = vi[rechts];
	    vi[rechts] = tmp;
	    
	    // Noch einen Schritt weiter gehen um 
	    links++;
	    rechts--;
	}
    }

    // Vertauschen des kleinsten Elements im rechten Teilbaum mit Pivot-Element
    // Links steht nun auf dem 1. Element im rechten Teilbaum
    int tmp = vi[pivot];
    vi[pivot] = vi[links];
    vi[links] = tmp;

    // Rechts = neuer OI für linke Seite
    // Wenn eine Seite noch mehr als 1 Element enthält..
    if (ui < rechts)
	quicksort(vi, ui, rechts);
    
    // Links = neuer UI für rechte Seite
    // Wenn eine Seite noch mehr als 1 Element enthält..
    if (oi > links)
	quicksort(vi, links, oi);
}

int main() {

    // Initialisieren und befüllen des Vektors
    vector vi;
    vi.push_back(4);
    vi.push_back(7);
    vi.push_back(2);
    vi.push_back(8);
    vi.push_back(1);
    vi.push_back(9);
    vi.push_back(0);
    vi.push_back(6);
    vi.push_back(3);
    vi.push_back(5);
    
    // Ausgabe des unsortierten Vektors
    ausgabe(vi);
    
    // Parameter für Suche initialisieren
    int ui = 0;
    int oi = vi.size() - 1;
    
    // Aufruf der Suche
    quicksort(vi, ui, oi);
    
    // Ausgabe des sortierten Vektors
    ausgabe(vi);
    return 0;
}

Der Beitrag Programmieren, Algorithmen und Datenstrukturen 2 (Vorlesung 20) erschien zuerst auf Maximilian Krieg.

• Als Indexstruktur werden Streuwerttabellen verwendet um Datenelemente in einer großen Datenmenge aufzufinden
• Streuerttabellen zeichnen sich durch einen üblicherweise konstanten Zeitaufwand bei Einfüge- bzw. Entfernen-Operationen aus
• Die Größe M einer Streuwerttabelle sollte eine Primzahl sein, da bei nicht-Primzahlen beim Addieren eines Vielfachen von M zum Schlüsselwert der selbe Streuwert erzeugt werden kann → Kollision

Anwendung

• Zeichenketten können in ganzzahlen umgerechnet werden
  • Diese können dann modular gestreut werden

Beispiel:

• Schlüssel seien Zeichenketten aus vier Großbuchstaben

H            A           N              S 8            1           14            19 01000     00001     01110       10011 8*32^3 + 1*32^2 + 14*32^1 + 19*32^0 = 263635 263635 ≡ x (mod 101) → x = 25  Beim Rechnen mit langen Zeichenketten können Zahlen entstehen, die für die meisten Computer zu groß sind

• Rechentrick: Hornerschema (Beispiel: L05 – S. 44)
  • Bei jeder Rechnung wird nur mit dem Rest modulo M weitergerechnet

Kollisionsbehandlung: getrennte Verkettung

• Für jede Tabellenadresse wird eine verkettete Liste angelegt, die alle Knoten enthält, deren Schlüssel auf diese Adresse abgebildet wurden.

Kollisionsbehandlung: offene Adressierung

• Voraussetzungen
  • Maximale Anzahl der Elemente, die gespeichert werden sollen kann vorher ungefähr abgeschätzt werden
  • genug zusammenhängender Speicher vorhanden
• Streuwerttabelle wird gleich als Datenfeld erzeugt
• Bei Kollisionen wird auf die freien Plätze in der Streuwert-Tabelle ausgewichen

Zusammenfassung: Streuwerttabellen

• Zwei Extrema
  • Ohne Speicherbeschränkung, mit beliebig großen Streuwert-Tabellenkönnte jede Suche mit nur einem einzigen Speicherzugriff realisiert werden.
  • Ohne Zeitbeschränkung könnte jede Suche mit nur minimalem Speicherplatz realisiert werden
• Mit Streuwerttabellen kann das Verhältnis zwischen diesen beiden Richtungen beliebig bestimmt werden.
  • Durch Anpassung der Größe der Tabelle

Letzte Vorlesungseinheit: Fortgeschrittenes Sortieren

Insertionsort:

 void insSort( vector<T>& vV, int ui, int oi ) {
    int i(0), j(0); T tmp = T();
    for( i=oi; i>ui; --i ) swap_if( vV[i-1], vV[i] );
    for( i=ui+2; i<=oi; ++i ) {
        j = i; tmp = vV[i];
        while( tmp<vV[j-1] ) {
            vV[j] = vV[j-1];
            --j;
        }
        vV[j] = tmp;
    }
 }

Problem: Elemente, die sich in den ursprünglichen, unsortierten Daten weit entfernt vonihrer späteren, endgültigen Position innerhalb der sortierten Daten befinden, müssen mit vielen benachbarten Elementen einzeln vertauscht werden.

Lösung: Shellsort

• Elemente, die weit voneinander entfernt liegen, werden zuerst direkt vertauscht
• h-sortierte Daten: Daten werden h-sortiert genannt, wenn man durch Entnahme jedes h-ten Elements sortierte Daten erhält.

Beispiel: absteigend 3-sortierte Daten 25  830  67  17  320  55  14  288  49  11  245  33  9  170  24  6  143  21  4  99  16 25  830  67  17  320  55  14  288  49  11  245  33  9  170  24  6  143  21  4  99  16 25  830  67  17  320  55  14  288  49  11  245  33  9  170  24  6  143  21  4  99  16

• Beobachtung:
  • h-sortiert man k-sortierten Daten, ist das Ergebnis sowohl h- als auch k-sortiert

Beispiel: Eine 1-Sortierung entspricht der Insertion Sort. Durch das Sortieren bei „Shell-Sort“ werden ungünstige Fälle aussortiert.

Implementierung

template<class T> void shlsrt( vector<T> vV,    int ui, int oi ) {
  int i(0), j(0), h(0), d(-1);
  T tmp = T();
  while( h <= (oi-ui+1)/9 ) h = (3*h)+1; // Startwert für h
    for( ; h>0; h /= 3 ) {
      while( ++d < h ) {
// kleinstes Element jeweils an den Anfang:
        for( i=oi-d; i>=ui+h; i-=h ) swap_if(   vV[i-h], vV[i] );
// sortieren:
        for( i+=h; i<=oi; i+=h ) {
          j=i; tmp = vV[i];
          while( tmp < vV[j-h] )
        }
      } // "d-Schleife"
    d = -1;
 } // "h-Schleife"
}

Eigenschaften von Shellsort

• Leistungseigenschaften können nur ungenau beschrieben werden
  • Niemand konnte den Algorithmus bis wirklich analysieren
• Hat keinen Worst-Case
  • ist nicht abhängig von ursprünglichen Ordnung
• kein stabiles Sortierverfahren
  • Ein stabiles Sortierverfahren ist ein Sortieralgorithmus, der die Reihenfolge der Datensätze, deren Sortierschlüssel gleich sind, bewahrt.
• sehr kurzes Programm und einfach zu implementieren

Der Beitrag Programmieren, Algorithmen und Datenstrukturen 2 (Vorlesung 19) erschien zuerst auf Maximilian Krieg.

• Jeden Knoten einmal besuchen

Baum

Einfügen wird durch Vergleich mit aktuellem Element und wandern bis zur ersten freien Stelle mit ständigen Vergleichen realisiert

entartet, wenn man sortierte Listen einfügt

Der Beitrag Programmieren, Algorithmen und Datenstrukturen 2 (Vorlesung 18) erschien zuerst auf Maximilian Krieg.

• Für die Algorithmenanalyse ist oft der durchschnittliche Fall am wichtigsten
• Stirling-Zahl (1. Art)
  • Anzahl der Permutationen einer n-elementigen Menge, die genau k Zyklen haben (Wikipedia)

Bäume

→ Mathematische Struktur, Graph

• Knoten
  • sind miteinander verbunden
  • haben
• Kanten
• Pfad
  • Weg von einem Knoten zu einem anderen über eine oder mehrere Kanten
  • In einem Baum gibt es immer genau einen Pfad
  • Kanten sind zunächst ungerichtet

Wurzelbaum

• Knoten sind als Wurzel gekennzeichnet
  • Gegenteil: freier Baum
• Kanten zeigen zur Wurzel oder von ihr weg (es kann auch beides der Fall sein)
  • Kanten sind gerichtet
• Die Wurzel befindet sich oben
  • ein Knoten y liegt über dem Knoten x, wenn er sich näher an der Wurzel befindet
• Jeder Knoten bildet die Wurzel für einen weiteren Teilbaum
• Jeder Knoten, der nicht die Wurzel ist, hat einen Vorgänger (Knoten direkt über ihm) und Nachfolger (Knoten direkt unter ihm)
• Knoten ohne Nachfolger heißen Blätter

• Knotenebene
  • Ebene der Wurzel ist „0“
  • Ebene ist der Abstand vom Knoten zur Wurzel
• Pfadlänge
  • Summer aller Ebenen
• Höhe eines Wurzelbaums
  • Die höchste Ebene unter allen Knoten

Geordneter Baum

• Reihenfolge der Nachfolger jedes Knotens ist systematisch festgelegt

M-wertiger Baum

• Jeder Knoten muss eine bestimmte Anzahl „M“ von Nachfolgern haben
• Pseudoknoten, äußerer Knoten
  • werden als Nachfolger von Knoten gesetzt, die keine „M“ Nachfolger haben
  • werden im Vergleich zu den runden „inneren“ Knoten eckig dargesetellt
• Nullkanten
  • Kanten zu Pseudoknoten
• Blätter haben nur Pseudoknoten als Nachfolger

Binärbaum

• geordneter M-wertiger Baum mit M=2
• 2 Typen von Knoten:
  • Äußere Knoten
  • Innere Knoten
• geordnet
  • linker Nachfolger
  • rechter Nachfolger
  • jeder Knoten hat genau 2 Nachfolger
• Blätter haben 2 äußere Knoten als Nachfolger
• äußere Pfadlänge
  • Summe der Ebenen aller äußeren Knoten
• innere Pfadlänge
  • Summe der Ebenen aller inneren Knoten

Die Implementierung eines Binärbaums in C++ sieht wie folgt aus:

struct node { char c; node* left; node* right; }

• Ein Binärbaum von N Knoten hat N-1 Kanten
• Ein Binärbaum von N inneren Knoten hat N+1 äußere Knoten
• Ein Binärbaum mit N inneren Knoten hat 2N Kanten
• Die äußere Pfadlänge eimes Binärbaums mit N inneren Knoten ist um 2N größer als seine innere Pfadlänge
• Die Höhe eines Binärbaums mit N inneren Knoten beträgt
  • mindestens log2 (N)
  • höchstens N
• Die innere Pfadlänge eines Binärbaums mit N inneren Knoten beträgt mindestens log2 (N/4) und höchstens N (N-1) / 2

Der Beitrag Programmieren, Algorithmen und Datenstrukturen 2 (Vorlesung 17) erschien zuerst auf Maximilian Krieg.

a) Kehren Sie zu den Ergebnissen aus der Aufgabe 2 des zweiten Praktikums zurück, und implementieren Sie die Shape und Frame Klassen(-hierarchie) zur Darstellung geometrischer Figuren als Punkteraster auf der Konsole zu Ende. Ihre Implementierung des Bresenham-Algoritmus zur Ermittlung der Rasterpunkte einer geraden Linie wird zur Methode void Line::draw( Frame* ) und die Frame Klassenhierarchie wird weiter verwendet. Erweitern Sie Ihren Testplan und Ihren main() Treiber entsprechend, überprüfen Sie alles systematisch und wiederholbar. Dokumentieren Sie die Testplanung und die Ergebnisse.

b) Erweitern Sie die Klassenstruktur um class Triangle : public shape, damit entsprechend zu den bisherigen Figurtypen nun auch Dreiecke mit draw() und move() behandelt werden können. Ermöglichen Sie Dreiecke durch Übergabe der Koordinaten der drei Eckpunkte. Konzentrieren Sie sich beim Test auf die Methode, die prüft, ob die drei übergebenen Punkte ein gültiges Dreieck darstellen. Testen Sie wieder geplant, systematisch und ausführlich, dokumentieren Sie wieder alle Tests und Ergebnisse.

c) Erweitern Sie den Typ Triangle so, dass man Triangle Objekte auch erzeugen kann, indem man einem weiteren Konstruktor die horizontale und vertikale Koordinate eines Bezugspunktes („links-unten“) sowie drei int Werte übergibt, die die Seitenlängen des Dreiecks darstellen: Triangle( int hor, int ver, int len1, int len2, int len3 ) //… Konzentrieren Sie sich beim Test auf die Methode, die prüft, ob die drei übergebenen Längen ein gültiges Dreieck darstellen. Erweitern Sie den Testplan, dokumentieren Sie die Ergebnisse.

Lösung

/*
 * File:   main.cpp
 * Author: maximilian.krieg
 *
 * Created on 20. April 2012, 12:41
 */

#include "headers.h"
using namespace std;

int main() {

    Frame frame1;
    Frame* pFrame1 = &frame1;

    // Standardkonstruktor Linie
    Line test0();
    dump_all_shapes(pFrame1);

    // Ungültige Linie
    Line test1(5,5,XMAX+1,YMAX+1);
    dump_all_shapes(pFrame1);

    // Linie auf den Frame schieben
    test1.move(-2,-2);
    dump_all_shapes(pFrame1);

    return 0;
}

    //        // Test #0: Start
    //        //<editor-fold defaultstate="collapsed" desc="Testfall #0: Ungültige Linien zeichnen, Std. Konstruktor + Korrektur">

//    //Standard-Konstruktor aufrufen
//    Line test0();
//
//    //Ungültige Linie zeichnen
//    Line test1(-1, 0, 5, -7);
//
//    // Gültige Linie zeichnen und ins Aus schieben
//    Line test2(5,5,XMAX-5,YMAX-5);
//    dump_all_shapes(pFrame1);
//    test2.set(-1,-5,XMAX+1,YMAX+1);
//    dump_all_shapes(pFrame1);
//
//    // Linie neu setzen
//    pFrame1->frame_reset();
//    test2.set(5,5,XMAX-5,5);
//    dump_all_shapes(pFrame1);

    //        //</editor-fold>
    //        // Test #0: Ende

    //        // Test #1: Start
    //        //<editor-fold defaultstate="collapsed" desc="Testfall #1: Stern zeichnen + Fehler: Linien ins Aus verschieben">
    //
    //        // Stern-Linien setzen
    //        Line line1(10,10 , 10, 20); // Norden
    //        Line line2(10,10 , 20, 10); // Osten
    //        Line line3(10,10 , 10, 0); // Süden
    //        Line line4(10,10 , 0,10); // Westen
    //        Line line5(10,10 , 0, 0); // Südwesten
    //        Line line6(10,10 , 20, 0); // Südosten
    //        Line line7(10,10 , 20, 20); // Nordosten
    //        Line line8(10,10 , 0, 20); // Nordwesten
    //        dump_all_shapes(pFrame1);
    //
    //        // Fehler: Stern-Linien ins Aus schieben
    //        line1.move((-XMAX) - 1, 0);
    //        line2.move((XMAX) + 1, 0);
    //        line3.move(0, YMAX + 1);
    //        line4.move(0, (-YMAX) - 1);
    //        dump_all_shapes(pFrame1);
    //
    //
    //        //</editor-fold>
    //        // Test #1: Ende

    //        // Test #2: Start
    //        //<editor-fold defaultstate="collapsed" desc="Testfall #2: Haus zeichnen + Linien erfolgreich verschieben">
    //        // Haus-Koordinaten
    //
    //        // Haus-Linien
    //        Line line9(15, 30, 25, 20);
    //        Line line10(25, 20, 5, 20);
    //        Line line11(5, 20, 15, 30);
    //        Line line12(5, 20, 5, 0);
    //        Line line13(5, 0, 25, 0);
    //        Line line14(25, 0, 25, 20);
    //        Line line15(5, 0, 25, 20);
    //        Line line16(5, 20, 25, 0);
    //        dump_all_shapes(pFrame1);
    //
    //        // Haus #2
    //        pFrame1->frame_reset();
    //        line9.move(25, 0);
    //        line10.move(25, 0);
    //        line11.move(25, 0);
    //        line12.move(25, 0);
    //        line13.move(25, 0);
    //        line14.move(25, 0);
    //        line15.move(25, 0);
    //        line16.move(25, 0);
    //        dump_all_shapes(pFrame1);
    //        //</editor-fold>
    //        // Test #2: Ende

    //        // Test #3: Start
    //        //<editor-fold defaultstate="collapsed" desc="Testfall #3: 2 Dreiecke zeichnen">
    //        //Dreieck #1: Rechtwinklig
    //        Triangle triangle1(5,40, 10, 40, 5,55);
    //
    //        //Dreieck #2: Gleichschenklig
    //        Triangle triangle2(30,40,50,40,40,60);
    //        dump_all_shapes(pFrame1);
    //        //</editor-fold>
    //        // Test #3: Ende

    //        // Test #4: Start
    //        //<editor-fold defaultstate="collapsed" desc="Testfall #4: Dreieck zeichnen + verschieben + Fehler: Ins Aus verschieben">
    //
    //        //Dreieck #3: Beliebig
    //        Triangle triangle3(9,63,42,40,32,65);
    //        dump_all_shapes(pFrame1);
    //
    //        // Dreieck #3: Verschieben
    //        pFrame1->frame_reset();
    //        triangle3.move(-5, -37);
    //        dump_all_shapes(pFrame1);
    //
    //        // Fehler: Dreieck ins Aus schieben
    //        triangle3.move(200, 0);
    //        triangle3.move(-200, 0);
    //        triangle3.move(0, +200);
    //        triangle3.move(0, -200);
    //        dump_all_shapes(pFrame1);
    //
    //        //</editor-fold>
    //        // Test #4: Ende

    //        // Test #5: Start
    //        //<editor-fold defaultstate="collapsed" desc="Testfall #5: Dreieck im Aus zeichnen und auf den Frame schieben">
    //
    //        // Dreieck #4 im Aus zeichnen
    //        Triangle triangle4(15,15,30, YMAX+1,(-5),30);
    //        dump_all_shapes(pFrame1);
    //
    //        // Dreieck 4 auf den Frame schieben
    //        triangle4.move(+10, -10);
    //        dump_all_shapes(pFrame1);
    //        //</editor-fold>
    //        // Test #5: Ende

    //            // Test #6: Start
    //    //<editor-fold defaultstate="collapsed" desc="Testfall #6: Ungültiges Dreieck zeichnen + Korrektur">
    //        // Ungültiges Dreieck #5 zeichnen (2 Punkte identisch)
    //        Triangle triangle5(15,15, 15,15,5,5);
    //        dump_all_shapes(pFrame1);
    //
    //        // Ungültiges Dreieck #5 zeichnen: Punkte neu setzen (3 Punkte bilden eine Gerade)
    //        triangle5.set(15,15,10,10,20,20);
    //        dump_all_shapes(pFrame1);
    //
    //        // Dreieck #5: Die Punkte korrekt setzen
    //        triangle5.set(20,7,41,10,23,21);
    //        dump_all_shapes(pFrame1);
    //
    //    //</editor-fold>
    //        // Test #6: Ende

/*
 * File:   headers.h
 * Author: maximilian.krieg
 *
 * Created on 27. April 2012, 10:34
 */

#ifndef HEADERS_H
#define	HEADERS_H

// Präprozessordirektiven aller Header
#include <iostream>
#include "Frame.h"
#include "Shape.h"
#include "Line.h"
#include "Triangle.h"

// Deklaration aller Klassen
class Coordinate;
class Frame;
class Shape;
class Line;
class Triangle;

#endif	/* HEADERS_H */

/*
 * File:   Frame.h
 * Author: maximilian.krieg
 *
 * Created on 20. April 2012, 12:42
 */

#ifndef FRAME_H
#define	FRAME_H

const int XMAX = 55; // Zeichen pro Frame-Zeile (55)
const int YMAX = 70; // Zeilen pro Frame   (34)

class Frame {
public:

    enum color {
	on = ' ', off = 254
    };

    Frame();
    void put_point(int, int); // Punkt im Frame speichern
    void frame_reset(); // Frame "leeren"
    void frame_dump() const; // Frame auf die Konsole ausgeben
    bool on_frame(int, int) const; // "Clipping"

private:
    char frame[XMAX][YMAX];
};
#endif	/* FRAME_H */

/*
 * File:   Frame.cpp
 * Author: maximilian.krieg
 *
 * Created on 20. April 2012, 12:42
 */

#include "headers.h"
using std::cout;
using std::endl;
using std::string;

// Standardkonstruktor für Frames

Frame::Frame() {
    frame_reset();
}

// Punkt im Frame speichern

void Frame::put_point(int x, int y) {
    if (on_frame(x, y)) {
	frame[x][y] = on;
    }
}

// Frame "leeren"

void Frame::frame_reset() {
    for (int x = 0; x < XMAX; x++) {
	for (int y = 0; y < YMAX; y++) {
	    frame[x][y] = off;
	}
    }
}

// Frame auf die Konsole ausgeben

void Frame::frame_dump() const {
    for (int y = YMAX - 1; y >= 0; --y) {
	for (int x = 0; x < XMAX; x++) {
	    cout << frame[x][y];
	}
	cout << endl;
    }
    cout << endl;
}

// "Clipping"

bool Frame::on_frame(int x, int y) const {
    if (x >= 0 && x < XMAX && y >= 0 && y < YMAX) {
	return true;
    } else {
	return false;
    }
}

/*
 * File:   Shape.h
 * Author: maximilian.krieg
 *
 * Created on 27. April 2012, 10:09
 */
#include "headers.h"

#ifndef SHAPE_H
#define	SHAPE_H

class Shape {
public:

    Shape();
    Shape* next; // Zeiger auf die nächste Figur
    static Shape* list; // Zeiger auf die Liste aller erzeugten Figuren

    virtual void draw(Frame* ptarget) = 0; // rein virtuelle Methode
    virtual void move(int hor, int ver) = 0; // rein virtuelle Methode

};

// gibt die abgeleiteten Shape Objekte auf Frame* aus
void dump_all_shapes(Frame*);

#endif	/* SHAPE_H */

/*
 * File:   Shape.cpp
 * Author: maximilian.krieg
 *
 * Created on 27. April 2012, 10:09
 */

#include "headers.h"

Shape* Shape::list = 0; // initialisiert den static Member mit dem Nullzeiger

Shape::Shape() :
next(list) {
    list = this;
}

void dump_all_shapes(Frame* pFrame) // gibt die abgeleiteten Shape Objekte auf Frame* aus
{
    for (Shape* s = Shape::list; s; s = s->next) {
	s->draw(pFrame);
    }
    pFrame->frame_dump();
}

/*
 * File:   Line.h
 * Author: maximilian.krieg
 *
 * Created on 27. April 2012, 10:19
 */
#include "headers.h"
#ifndef LINE_H
#define	LINE_H

class Line : public Shape {
public:
    // Konstruktoren
    Line(); // Standardkonstruktor
    Line(int, int, int, int); // Konstruktor mit 2 Koordinaten (A[x/y];B[x/y])

    // Modifizieren der Linie ( neu setzen oder verschieben )
    void set(int, int, int, int); // Koordinaten neu setzen (A[x/y];B[x/y])
    void move(int, int); // rein virtuelles shape::move() überschreiben

    // Print-Methode
    void draw(Frame*); // rein virtuelles shape::draw()überschreiben

    // Check-Methoden
    bool checkpos(int, int) const; // Gültigkeit der Koordinaten prüfen
private:
    int AX, AY, BX, BY; // Koordinaten (A[x/y];B[x/y])
};

#endif	/* LINE_H */

/*
 * File:   Line.cpp
 * Author: maximilian.krieg
 *
 * Created on 27. April 2012, 10:19
 */

#include "headers.h"
using std::cerr;
using std::endl;

Line::Line() // Definition des Standardkonstruktors
: Shape(), AX(-1), AY(-1), BX(-1), BY(-1) { // Koordinaten werden ungültig gesetzt
}

Line::Line(int ax, int ay, int bx, int by) // Def. des weiteren Konstuktors
: Shape(), AX(ax), AY(ay), BX(bx), BY(by) {
    if (checkpos(0, 0) == false) {
	AX = -1;
	AY = -1;
	BX = -1;
	BY = -1;
	cerr << "Linie konnte wegen ungültigen Koordinaten nicht gesetzt werden." << "Bitte alle Koordinaten neu setzen oder Linie verschieben." << endl;
    }
}

bool Line::checkpos(int h, int v) const {

    if (AX + h > XMAX || AX + h < 0) {
	cerr << "Koordinate liegt nicht auf dem Frame: ";
	return false;
    }
    if (AY + v > YMAX || AY + v < 0) {
	cerr << "Koordinate liegt nicht auf dem Frame: ";
	return false;
    }
    if (BX + h > XMAX || BX + h < 0) {
	cerr << "Koordinate liegt nicht auf dem Frame: ";
	return false;
    }
    if (BY + v > YMAX || BY + v < 0) {
	cerr << "Koordinate liegt nicht auf dem Frame: ";
	return false;
    }
    return true;
}

void Line::set(int ax, int ay, int bx, int by) {
    int backup_ax=AX;
    int backup_ay=AY;
    int backup_bx=BX;
    int backup_by=BY;

    AX = ax;
    AY = ay;
    BX = bx;
    BY = by;

    if (checkpos(0,0)== false)
    {
	AX=backup_ax;
	AY=backup_ay;
	BX=backup_bx;
	BY=backup_by;
	cerr << "Koordinaten wurden zurückgesetzt." << endl;
    }
}

void Line::move(int h, int v) { // Def. der line::move() Methode
    if (checkpos(h, v) == true) {
	AX = AX + h;
	AY = AY + v;
	BX = BX + h;
	BY = BY + v;
	std::cout << "Linie erfolgreich verschoben." << endl;
    } else {
	cerr << "Linie kann nicht verschoben werden." << endl;
    }
}

// Tauschen von Variablen

void swap(int& a, int& b) {
    int help = 0;
    help = a;
    a = b;
    b = help;
}

// Bresenham Algorithmus

void Line::draw(Frame* pFrame) {

    bool bMerker1 = false;
    bool bMerker2 = false;

    int iX_end = BX;
    int iX_start = AX;
    int iY_start = AY;
    int iY_end = BY;

    if (iX_end < iX_start) {

	// Start- und Endpunkt vertauschen
	swap(iX_start, iX_end);
	swap(iY_start, iY_end);
    }

    if (iY_end < iY_start) {
	// Vorzeichen beider Y-Koordinaten umdrehen
	iY_end = -iY_end;
	iY_start = -iY_start;
	//und dafür einen Merker setzen
	bMerker1 = true;
    }

    if ((iX_end - iX_start) < (iY_end - iY_start)) {

	swap(iX_start, iY_start); // iX_start mit iY_start vertauschen
	swap(iX_end, iY_end); // iX_end mit iY_end vertauschen
	bMerker2 = true; // dafür einen weiteren Merker setzen
    }

    int dx = iX_end - iX_start;
    int dy = iY_end - iY_start;
    int d = (2 * dy) - dx;
    int y = iY_start;

    for (int x = iX_start; x <= iX_end; ++x) {

	// flach & steigend
	if (bMerker1 == false && bMerker2 == false) {
	    pFrame->put_point(x, y); // Punkt im Frame setzen
	}

	// flach & fallend
	if (bMerker1 == true && bMerker2 == false) {
	    pFrame->put_point(x, -y); // Punkt im Frame setzen
	}

	// steil & steigend
	if (bMerker1 == false && bMerker2 == true) {
	    pFrame->put_point(y, x); // Punkt im Frame setzen
	}

	// steil & fallend
	if (bMerker1 == true && bMerker2 == true) {
	    pFrame->put_point(y, -x); // Punkt im Frame setzen
	}

	//error = error + delta; // Fehler aktualisieren
	if (d < 0) {
	    d = d + 2 * dy; // Fehler anpassen
	} else {
	    y++; // Rechts und hoch gehen
	    d = d + 2 * (dy - dx);
	}
    }
}

/*
 * File:   Triangle.h
 * Author: maximilian.krieg
 *
 * Created on 27. April 2012, 11:00
 */

#include "headers.h"

#ifndef TRIANGLE_H
#define	TRIANGLE_H

class Triangle : public Shape {
public:
    //Konstruktoren
    Triangle(); // Standard-Konstruktor
    Triangle(int, int, int, int, int , int); //Konstruktor mit 3 Koordinaten A[x/y], B[x/y], C[x/y]
    Triangle(int ax, int ay, int laenge_a, int laenge_b, int laenge_c);

    //Koordinaten neu setzen A[x/y], B[x/y], C[x/y]
    void set(int , int , int , int , int , int);

    // Dreieck auf dem Frame zeichnen. ( 3 Linien zeichnen )
    void draw(Frame*);

    //Dreick verschieben um h ( x-Achse )und v ( y-Achse )
    void move(int, int);

    // Prüfen, ob das Dreieck auf dem Frame liegt
    bool checkpos(int, int);

private:
    int AX, AY; // Koordinaten von Punkt A
    int BX, BY; // Koordinaten von Punkt B
    int CX, CY; // Koordinaten von Punkt C
    Line ab; // Linie von A zu B
    Line bc; // Linie von B zu C
    Line ac; // Linie von A zu C
};

#endif	/* TRIANGLE_H */

/*
 * File:   Triangle.cpp
 * Author: maximilian.krieg
 *
 * Created on 27. April 2012, 11:00
 */

#include "headers.h"
#include <math.h>
using std::cout;
using std::cerr;
using std::endl;

// Standard-Konstruktor
Triangle::Triangle() :
Shape(), AX(-1), AY(-1), BX(-1), BY(-1), CX(-1), CY(-1) {
}

// Konstruktor für 3 Koordinaten A[x/y], B[x/y], C[x/y]
Triangle::Triangle(int ax, int ay, int bx, int by, int cx, int cy) :
Shape(), AX(ax), AY(ay), BX(bx), BY(by), CX(cx), CY(cy) {
    if (checkpos(0, 0) == true) {
	ac.set(ax, ay, cx, cy);
	ab.set(ax, ay, bx, by);
	bc.set(bx, by, cx, cy);
    } else {
	cerr << "Dreieck kann nicht gezeichnet werden." << endl;
    }
}

// Überschreiben der virtuellen draw-Methode von Shape
void Triangle::draw(Frame* pFrame) {
    ac.draw(pFrame);
    bc.draw(pFrame);
    ab.draw(pFrame);
}

// Dreieck verschieben um h (x-Achse) und v (y-Achse).
// Prüfung erfolgt mittels Vorbedingung.
void Triangle::move(int h, int v) {

    // Prüfen, ob das Dreieck nach dem Verschieben gültig wäre
    if (checkpos(h, v) == true) {
	AX = AX + h;
	AY = AY + v;
	BX = BX + h;
	BY = BY + v;
	CX = CX + h;
	CY = CY + v;

	// Linien neu setzen
	ac.set(AX, AY, CX, CY);
	ab.set(AX, AY, BX, BY);
	bc.set(BX, BY, CX, CY);

	cout << "Dreieck erfolgreich verschoben." << endl;
    } else {
	cerr << "Dreieck kann nicht verschoben werden." << endl;
    }
}

// Länge einer Linie berechnen
double laenge(int ax, int ay, int bx, int by) {
    double dlaenge = ((bx - ax)*(bx - ax)) + ((by - ay)*(by - ay));
    dlaenge = sqrt(dlaenge);
    return dlaenge;
}

// Prüfen, ob ein Dreieck gültig ist.
bool Triangle::checkpos(int h, int v) {

    // Position prüfen, liegt die neue Koordinate auf dem Frame?, liegt die neue Koordinate auf dem Frame?
    if (AX + h > XMAX || AX + h < 0) {
	std::cerr << "Dreieck liegt nicht auf dem Frame: ";
	return false;
    }
    // Position prüfen, liegt die neue Koordinate auf dem Frame?
    if (AY + v > YMAX || AY + v < 0) {
	std::cerr << "Dreieck liegt nicht auf dem Frame: ";
	return false;
    }
    // Position prüfen, liegt die neue Koordinate auf dem Frame?
    if (BX + h > XMAX || BX + h < 0) {
	std::cerr << "Dreieck liegt nicht auf dem Frame: ";
	return false;
    }
    // Position prüfen, liegt die neue Koordinate auf dem Frame?
    if (BY + v > YMAX || BY + v < 0) {
	std::cerr << "Dreieck liegt nicht auf dem Frame: ";
	return false;
    }
    // Position prüfen, liegt die neue Koordinate auf dem Frame?
    if (CX + h > XMAX || CX + h < 0) {
	std::cerr << "Dreieck liegt nicht auf dem Frame: ";
	return false;
    }
    // Position prüfen, liegt die neue Koordinate auf dem Frame?
    if (CY + v > YMAX || CY + v < 0) {
	std::cerr << "Dreieck liegt nicht auf dem Frame: ";
	return false;
    }

    // Punkte auf Gleichheit prüfen.
    if ((CX == BX && BY == CY) || (BX == AX && BY == AY) || (CX == AX && CY == AY)) {
	std::cerr << "Zwei oder mehr Punkte sind identisch. Kein gültiges Dreieck: ";
	return false;
    }

    // Prüfen, ob 1 Punkt auf der Linie der anderen 2 Punkte liegt.
    double laenge_ac = laenge(AX, AY, CX, CY);
    double laenge_ab = laenge(AX, AY, BX, BY);
    double laenge_bc = laenge(BX, BY, CX, CY);

    if (((laenge_ac + laenge_ab) <= laenge_bc) || (laenge_ac + laenge_bc <= laenge_ab) || (laenge_ab + laenge_bc <= laenge_ac)) {
	std::cerr << "Die Laenge einer Seite ist gleich oder größer als die Summe der anderen Zwei Seiten. Kein gültiges Dreieck: ";
	return false;
    }

    return true;
}

// Koordinaten eines Dreiecks neu setzen.
// Prüfung erfolgt mittels Nachbedingung.
void Triangle::set(int ax, int ay, int bx, int by, int cx, int cy) {

    // Sichern der Koordinaten für etwaiges Zurückspielen
    int backup_ax = AX;
    int backup_ay = AY;
    int backup_bx = BX;
    int backup_by = BY;
    int backup_cx = CX;
    int backup_cy = CY;

    // Übertragen der Koordinaten
    AX = ax;
    AY = ay;
    BX = bx;
    BY = by;
    CX = cx;
    CY = cy;

    // Gültigkeit der neuen Koordinaten prüfen
    if (checkpos(0, 0) == true) {

	// Setzen der Linien
	ac.set(ax, ay, cx, cy);
	ab.set(ax, ay, bx, by);
	bc.set(bx, by, cx, cy);
    } else {

	// Zurücksetzen auf alte Koordinaten
	AX = backup_ax;
	AY = backup_ay;
	BX = backup_bx;
	BY = backup_by;
	CX = backup_cx;
	CY = backup_cy;
	std::cerr << "Punkte des Dreiecks können nicht gesetzt werden." << std::endl;
    }

}

Testplan

• Testfälle

Notizen:

• Probleme bei dem Testfall triangle(1,1,7,7,7), da in der ursprünglichen Lösung der berechnete Double-Wert der Längen zwischen Zwei punkten mittels return als Integer-Wert übergeben wurde. Somit wurden die Kommastellen  und es kam zu dem Fehler, dass das Dreieck nicht gezeichnet wurde. Dies betraf jedoch nur Längen mit einer Nachkommastelle größer als .5, dieser Fall wurde jedoch bei den Tests nicht erzeugt.
• Künftig müssen die Methoden gründlicher getestet werden!

Der Beitrag Programmieren, Algorithmen und Datenstrukturen 2 (Praktikum 3) erschien zuerst auf Maximilian Krieg.

• Map noch nicht in allen Compilern verfügbar

Verschlüsselung

#include
#include
#include
#include
#include
#include "error.h"
using namespace std;

int main( ) {

string name1 = "shuffled.txt";
string name2 = "klar.txt";
ifstream is( name1.c_str() );
if( !is ) error( "Kein Lesezugriff auf ", name1 );
if( ifstream( name2.c_str() ) )
error( "Datei existiert schon: ", name2 );
ofstream os( name2.c_str() );
if( !os ) error( "Kein Schreibzugriff auf ", name2 );
char c(' ');

// Entschlüsselung
while( (c=is.get()) != EOF ) os.put( (unsigned char)(c^4421)^883 );
return 0;
}

Suchen

• v[0] = 0.3141
• v[1] = 0.3141
• v[2] = 0.5555
• v[3] = 0.0

Der Beitrag Programmieren, Algorithmen und Datenstrukturen 2 (Vorlesung 16) erschien zuerst auf Maximilian Krieg.

• cin >> from >> to;  ← es werden keine Fehler abgefangen
• .c_str() Char-Array-String, der mit 0 terminiert wird „Test“ = ‚T‘ ‚e‘ ’s‘ ‚t‘ ‚\0‘
• Wir müssen STL-String in Char-Array umwandeln, weil das OS es so verlangt
• ifstream = input file stream
• istream_iterator<string> eos; ← Standardmäßig auf letztem Element

Erstellen einer Wortliste aus einem Textfile

#include <string>
#include <iterator>
#include <set>
#include <iostream>
#include <fstream>
using namespace std;

int main( ) {
	// Dateinamen für Quell- und Zieldatei einlesen:
	string from, to;
	cin >> from >> to;
	// Ein- und Ausgabe-Stream erstellen:
	ifstream is( from.c_str() ); ofstream os( to.c_str() );
	// Stream-Iterator zur Eingabe:
	istream_iterator<string> ii( is );
	// "end-of-stream" (wird standardmäßig auf EOF/end-of-file gesetzt):
	istream_iterator<string> eos;
	// Stream-Iterator zur Ausgabe, der jedesmal "\n" anhängt:
	ostream_iterator<string> oo( os, "\n" );
	// Das set-Objekt namens buffer wird mit dem Input initialisiert:
	set<string> buffer( ii, eos );
	//multiset<string> buffer( ii, eos );
	// buffer wird in die Ausgabedatei kopiert (set ist bereits sortiert und ohne Duplikate)
	copy( buffer.begin(), buffer.end(), oo );
	return 0;
}

Der Beitrag Programmieren, Algorithmen und Datenstrukturen 2 (Vorlesung 15) erschien zuerst auf Maximilian Krieg.

• Wie wäre ein binärer Suchbaum mit den sechs Knoten aus dem vorigen Beispiel maximal unvorteilhaft aufgebaut? → Ein komplett einseitig balancierter Baum

Ternärer Suchbaum

• Es müssen maximal log₃( N ) Knoten besucht werden

Klausur

• STL-Container kommen dran

Beispiel für map

/*
 * File:   main.cpp
 * Author: maximilian.krieg
 *
 * Created on 15. Mai 2012, 14:44
 */

#include <cstdlib>
#include <iostream>
#include <map>
#include <numeric>

using namespace std;

    double value_product(const pair<string, double>& a, const pair<string, double>& b)
    {
	return a.second * b.second;
    }

int main() {
    // Deutscher Aktienindex, 3-Jan-2012
    map<string, double> dax; // pair(symbol,price)
    dax["DAI"] = 36.11;
    dax["DTE"] = 9.13;
    dax["VOW"] = 122.10;
    // …
    map<string, double> dax_weight; // pair(symbol,weight)
    dax_weight.insert(make_pair("DAI", 5.7727));
    dax_weight.insert(make_pair("DTE", 5.3815));
    dax_weight.insert(make_pair("VOW", 3.3586));
    // …
    map<string, string> dax_name; // pair(symbol,name)
    dax_name["DAI"] = "Daimler";
    dax_name["DTE"] = "Deutsche Telekom";
    dax_name["VOW"] = "Volkswagen";
    // …

    double daimler_price = dax["DAI"]; // Werte aus der map lesen
    double volkswagen_price = dax["VOW"];

    if (dax.find("SOW") != dax.end()) // Eintrag suchen
	cout << "Software AG ist im DAX!\n";
    // über die map Elemente iterieren:

    typedef map<string, double>::const_iterator dax_iterator;

    for (dax_iterator p = dax.begin(); p != dax.end(); ++p) {
	const string& symbol = p->first; // das Symbol im "Ticker"
	cout << symbol << '\t' << p->second << '\t'
		<< dax_name[symbol] << '\n';
    }

    double dax_index =
	    inner_product(dax.begin(), dax.end(), // alle Firmen im DAX
	    dax_weight.begin(), // deren Gewichtung
	    0.0, // Initialisierung mit 0.0
	    plus<double>(), // addieren
	    value_product // zuerst multiplizieren
	    );

    cout << dax_index;
}

Der Beitrag Programmieren, Algorithmen und Datenstrukturen 2 (Vorlesung 14) erschien zuerst auf Maximilian Krieg.

• Vorgefertigte Container mit vielseitigen Funktionen
• Größtenteils standardisiert

STL

• Containerkonzept
• Begin() und End() sind die wichtigsten Interatoren einer Elementsequenz
• Ein Iterator ist ein Typ der mindestens die Operationen „++“, „*“ und „==“ beherrscht

Vector

• lückenloses und gekapseltes Datenfeld
• Zeiger zeigt auf das erste Element
• Beim Einfügen / Insert von Elementen werden alle Folgenden verschoben
• Wenn das letzte Element eingefügt wird muss nichts verschoben werden
• Alle Zeiger sind nach einem Insert / Delete unbrauchbar → neu bestimmen

Liste

• Funktionsweise nach außen hin wie bei Vector
• Aufbau „unter der Haube“ jedoch ganz anders
• leere List enthält mindestens das leere Element

Iterator

• Verbesserte Funktion der Zeiger

Accumulate

• Enthalten in <numeric>
• Verschieben des Zeigers auf das 1. Element um 1
• Addition der Summe + „1. Element“
• Überladen mit 4 Parametern

template
T accumulate( IterIn first, IterIn last, T init ){
while( first!=last ) {
init = init + *first;
++first;
}
return init;
}

//Anwendungsbeispiel
void f( vector& vd, int* p, int n )
{
	// addiere die Elemente von vd:
	// der Typ des 3. Arguments bestimmt auch die Rechengenauigkeit
	double sum = accumulate( vd.begin(), vd.end(), 0.0 );

	// addiere die int Werte in ein int (Überlauf gut möglich):
	// p+n kann man sich grob als &p[n] vorstellen
	int si = accumulate( p, p+n, 0 );

	// addiere die int Werte in ein long:
	long sl = accumulate( p, p+n, long(0) );

	// addiere die int Werte in ein double:
	double s2 = accumulate( p, p+n, 0.0 );

	// die Variable für den Rückgabewert kann im Initialisierer verwendet werden
	double s3 = 0;
	s3 = accumulate( vd.begin(), vd.end(), s3 );
}

int main()
{
	int sum = accumulate( v.begin(), v.end(), 0 );
	// sum wird 10
	// StdLib Header für accumulate(): numeric
}

template
T accumulate( IterIn first, IterIn last, T init, BinOp op )
{
	while( first!=last )
		{
			init = op( init, *first );
			// d.h. "init op *first"
			++first;
		}
	return init;
}

//Anwendungsbeispiel für Multiplikation
#include
void f( list& ld ) {
	double product = accumulate( ld.begin(), ld.end(), 1.0,
	multiplies() );
}

Funktoren

• Objekt, dass sich wie eine Funktion verhält und einen Rückgabetyp hat
• Erzeugung mittels Überladung der Operatorfunktion „()“

Klausur

• Funktoren könnten dran kommen

Multiplies

• bei nicht standardisierten Datentypen muss dieser Funktor überladen werden

Matrizen

• Objekt im 3. Raum → Tensor

Der map-Container

• Beinhaltet eine geordnete Sequenz von Schlüssel- Wert-Paaren, in der man anhand des Schlüssels nach dem zugehörigen Wert suchen kann

int main() {
  map<string,int> words; // Worte und ihre Häufigkeit
  string s;
  while( cin>>s && s!="quit" )
    ++words[s]; // der Schlüssel von words ist vom Typ string
                // die int Werte von words werden mit 0 initialisiert
                // wenn s schon enthalten ist, erhöht map dessen Wert mit ++ um 1
                // wenn s noch nicht enthalten ist, wird ein (s,0)-Paar
                // eingefügt und mit ++ auf den Wert 1 erhöht
                // words[s] liefert int& als Anzahl des Worts s
  typedef map<string,int>::const_iterator Iter;
  for( Iter p = words.begin(); p != words.end(); ++p )
    cout << p->first << ':' << p->second << '\n';
  return 0;
}

Ende: Seite 42

Der Beitrag Programmieren, Algorithmen und Datenstrukturen 2 (Vorlesung 13) erschien zuerst auf Maximilian Krieg.

• Verschiebung aller Praktika um 1 Woche

Iteratoren

• bilden eine Isolierschicht zu Containern
• sind eine Klasse innerhalb einer anderen Klasse
• erfüllen mindestens die Kriterien:
  • a==b
  • a!=b
  • *a
  • *a=wert
  • wert = *a
  • ++a
• Typen:
  • input
  • output
  • forward
  • bidirectional
  • random access

Sentinel

• ist ein Iterator ( Eingebettete Klasse der Liste )
• eine Stelle hinter dem letzten Element = .end()
• verhindert, dass man über die Liste hinaus geht
• ermöglicht den direkten Vergleich begin==end → leere Liste

Templates

• Ohne Standardkonstruktor lässt es sich nicht kompilieren

myIterator

• myNode<Elem>* _curr() const;  wichtig zum Debuggen

Der Beitrag Programmieren, Algorithmen und Datenstrukturen 2 (Vorlesung 12) erschien zuerst auf Maximilian Krieg.