C++ Kurs

Algorithmen II

Die Themen:

HinweisUm die nachfolgenden Beispiele ausführen zu können, benötigen Sie die Headerdatei object.h, welche im vorherigen Kapitel beschrieben ist.

Mutierende Algorithmen

Folgende mutierenden Algorithmen stehen zur Verfügung:

Algorithmus Beschreibung
next_permutation() Bildet die nächste Kombination der Elemente
partition() Bringt die Elemente, die einer bestimmten Bedingungen genügen, an den Anfang des Containers
prev_permutation() Bildet die vorherige Kombination der Elemente
random_shuffle() Mischt die Elemente zufällig
reverse() Kehrt die Reihenfolge der Elemente um
reverse_copy() Kopiert die Elemente in umgekehrter Reihenfolge
rotate() Rotiert (verschiebt) die Elemente
rotate_copy() Kopiert die Elemente in verschobener Reihenfolge
stable_partition() wie partition(), lässt aber die relative Reihenfolge der Elemente unverändert.

Die Funktion der Algorithmen dürfte bis auf die Permutationen aus ihrem Namen hervorgehen. Die Algorithmen next_permutation() und prev_permutation() kombinieren Elemente. Damit die Algorithmen alle Kombinationen berechnen können, sollten die Elemente in sortierter Reihenfolge vorliegen. Um für die Elemente in einem Container alle Permutationen berechnen zu lassen, ist die Funktion solange aufzurufen, bis diese false zurückliefert (siehe Beispiel).

Beispiel zu den mutierenden Algorithmen

PgmHeader// Beispiel zu Algorithmen
// Mutierende Algorithmen


#include <iostream>
// Algorithmen einbinden
#include <algorithm>
// ostream_iterator einbinden
#include <iterator>
// vordefinierte Functors einbinden
#include <functional>
// Container einbinden
#include <vector>
#include <set>
using std::cout;
using std::endl;

// #define TRACE_METH
#include "object.h"

// Functor fuer generate_n()
class Increment
{
    int value;
  public:
    Increment(): value(1)
    {}
    int operator()()
    {
        return value++;
    }
};

int main()
{
    // Container definieren/initialisieren
    using cType = std::set<Object>;
    cType cont {"Eins", "Zwei", "Drei", "Vier", "Fuenf"};

    cout << "Container-Inhalt:\n";
    std::copy(cont.begin(), cont.end(), std::ostream_iterator<Object>(cout,", "));
    cout << '\n';

    // Objekte in umgekehrter Reihenfolge aus dem Quell-Container umkopieren.
    // Beachten Sie bitte, dass Sie hier wieder einen Inserter benötigen,
    // da der Ziel-Container noch keine Elemente enthält

    using vType = std::vector<Object>;
    vType objVect;
    std::reverse_copy(cont.begin(), cont.end(), std::back_inserter(objVect));
    cout << "Set umgekehrt in Vektor umkopiert:\n";
    std::copy(objVect.begin(), objVect.end(), std::ostream_iterator<Object>(cout,", "));
    cout << '\n';

    // Die Elemente im Container mischen. Dieser Algorithmus könnte z.B.
    // zum Mischen von Karten eingesetzt werden.

    std::random_shuffle(objVect.begin(), objVect.end());
    cout << "'Druchgemischte' Vektor-Elemente:\n";
    std::copy(objVect.begin(), objVect.end(), std::ostream_iterator<Object>(cout,", "));
    cout << '\n';

    // Verschiebe die Elemente so, dass nun das 2. Element an erster
    // Stelle steht und das 0. und 1. Element hinten wieder angefügt wird

    std::rotate(objVect.begin(), objVect.begin()+2, objVect.end());
    cout << "Vektor-Elemente um 2 Positionen rotiert:\n";
    std::copy(objVect.begin(), objVect.end(), std::ostream_iterator<Object>(cout,", "));
    cout << '\n';

    // Alle Elemente die größer 'M' sind an den Anfang des Containers
    // verschieben. Die Reihenfolge der 'sortierten' Elemente ist dabei
    // nicht definiert.

    vType workCont(objVect);    // Hilfs-Container
    std::partition(workCont.begin(), workCont.end(),
                   std::bind2nd(std::greater<Object>(),Object("M")));
    cout << "Alle Elemente groesser 'M' nach vorne:\n";
    std::copy(workCont.begin(), workCont.end(), std::ostream_iterator<Object>(cout,", "));
    cout << '\n';

    // Das ganze Spiel nun nochmals, allerdings bleibt die relative Reihenfolge
    // der 'sortieren' Elemente bestehen und fuer den Vergleich
    // wird eine Lambda-Funktion verwendet

    workCont = objVect;       // Hilfs-Container erneut belegen
    Object compObj("M");      // Vergleichs-Objekt definieren
    std::stable_partition(workCont.begin(), workCont.end(),
                         [&compObj](Object& obj)
                         {
                             return obj>compObj;
                         });
    cout << "Alle Elemente groesser 'M' nach vorne (gleiche relative Reihenfolge):\n";
    std::copy(workCont.begin(), workCont.end(), std::ostream_iterator<Object>(cout,", "));
    cout << '\n';

    // Bilde alle Permutationen, die mit den Zahlen 1,2,3 moeglich sind
    // Hierzu werden die Werte in einem Vektor abgelegt und dann der Algorithmus
    // next_permuation() so lange aufgerufen, bis dieser false zurueckliefert.
    // Beachten Sie, dass der Inhalt des Containers sortiert sein sollte

    using iType = std::vector<int>;
    iType intVect;
    // Fortlaufende Zahlenfolge erzeugen und im Vektor ablegen
    int number = 1;
    std::generate_n(std::back_inserter(intVect),3,
                   [&number]()
                   {
                       return number++;
                   });
    cout << "Zu permutierender Container:\n";
    std::copy(intVect.begin(), intVect.end(), std::ostream_iterator<int>(cout,", "));
    cout << '\n';
    cout << "Permutiere Container-Elemente:\n";
    while (std::next_permutation(intVect.begin(), intVect.end()))
    {
        std::copy(intVect.begin(), intVect.end(), std::ostream_iterator<int>(cout,", "));
        cout << '\n';
    }
}
ProgrammausgabeContainer-Inhalt:
Drei, Eins, Fuenf, Vier, Zwei,
Set umgekehrt in Vektor umkopiert:
Zwei, Vier, Fuenf, Eins, Drei,
'Druchgemischte' Vektor-Elemente:
Drei, Vier, Eins, Fuenf, Zwei,
Vektor-Elemente um 2 Positionen rotiert:
Eins, Fuenf, Zwei, Drei, Vier,
Alle Elemente groesser 'M' nach vorne:
Vier, Zwei, Fuenf, Drei, Eins,
Alle Elemente groesser 'M' nach vorne (gleiche relative Reihenfolge):
Zwei, Vier, Eins, Fuenf, Drei,
Zu permutierender Container:
1, 2, 3,
Permutiere Container-Elemente:
1, 3, 2,
2, 1, 3,
2, 3, 1,
3, 1, 2,
3, 2, 1,

Sortierende Algorithmen

Folgende sortierenden Algorithmen stehen zur Verfügung:

Algorithmus Beschreibung
make_heap() Konvertiert einen Bereich in einen Heap (Erläuterung siehe unten)
nth_element() Sortiert die Elemente so, dass die n kleinsten/größten Elemente am Anfang des Containers stehen
partial_sort() Sortiert die Elemente so lange, bis n Elemente in sortierter Reihenfolge vorliegen
partial_sort_copy() Wie partial_sort(), nur werden die sortierten Elemente umkopiert
partition() Bringt die Elemente, die einer bestimmten Bedingungen genügen, an den Anfang des Containers
pop_heap() Entfernt ein Element vom Heap und fügt es am Ende des Containers wieder ein.
push_heap() Fügt ein Element zum Heap hinzu
sort() Sortiert Elemente
sort_heap() Konvertiert einen Heap in eine sortierte Reihenfolge
stable_sort() Sortiert Elemente, gleiche Elemente behalten ihre Reihenfolge
stable_partition() wie partition(), aber lässt die relative Reihenfolge der Elemente unverändert.

Heaps sind spezielle Reihenfolgen von Elementen innerhalb eines Bereichs [beg..end). Das erste Element im Heap ist das Element mit dem größten Wert. Ein Heap arbeitet etwa wie ein binärer Baum, nur in eben in einer sequentiellen Reihenfolge. make_heap() wandelt einen Bereich in einen Heap um und sort_heap() den Heap wieder zurück in eine sortierte Sequenz. Solche Heaps sind sehr gut geeignet, um Prioritäts-Queues zu implementieren. Der Standard-Container priority_queue verwendet z.B. die Heap-Algorithmen.

Beispiel zu den sortierenden Algorithmen

PgmHeader// Beispiel zu Algorithmen
// Sortierende Algorithmen


#include <iostream>
// Algorithmen einbinden
#include <algorithm>
// ostream_iterator einbinden
#include <iterator>
// vordefinierte Functors einbinden
#include <functional>
// Container einbinden
#include <vector>
using std::cout;
using std::endl;

int main()
{
    // Container definieren
    using cType = std::vector<int>;
    cType cont, work;
    // Container mit Zufallszahlen belegen
    std::generate_n(std::back_inserter(cont), 10, rand);
    // Zufallszahlen auf den Bereich 0...99 begrenzen
    std::transform(cont.begin(), cont.end(), cont.begin(),
                   std::bind2nd(std::modulus<int>(), 100));
    cout << "Container-Inhalt:\n";
    std::copy(cont.begin(), cont.end(), std::ostream_iterator<int>(cout,", "));
    cout << '\n';

    // Elemente abfallend sortieren, Standard ist steigend
    work = cont;
    std::sort(work.begin(), work.end(), std::greater<int>());
    cout << "Fallend sortiert:\n";
    std::copy(work.begin(), work.end(), std::ostream_iterator<int>(cout,", "));
    cout << '\n';

    // Nur vier Elemente im Container sortieren.
    // Die restlichen Elemente bleiben unsortiert!

    work = cont;
    cout << '\n';
    std::partial_sort(work.begin(), work.begin()+4, work.end());
    cout << "Vier Elemente sortiert:\n";
    std::copy(work.begin(), work.end(), std::ostream_iterator<int>(cout,", "));
    cout << '\n';

    // Die vier kleinsten Elemente an den Anfang des Container
    work = cont;
    std::nth_element(work.begin(), work.begin()+3, work.end());
    cout << "Die vier kleinsten Elemente an den Anfang:\n";
    std::copy(work.begin(), work.end(), std::ostream_iterator<int>(cout,", "));
    cout << '\n';

    // Kompletten Container in Heap umwandeln
    work = cont;
    std::make_heap(work.begin(), work.end());
    cout << "Nach der Umwandlung in einen Heap:\n";
    std::copy(work.begin(), work.end(), std::ostream_iterator<int>(cout,", "));
    cout << '\n';
    // Drei größten Werte vom Heap holen
    cout << "3 groessten Elemente vom Heap holen:\n";
    for (int i=0; i<3; i++)
    {
        // Größtes Element ausgeben
        cout << "--> " << *work.begin() << '\n';
        // Größtes Element jetzt ans Ende des Containers
        std::pop_heap(work.begin(), work.end());
        // Und dann aus dem Container entfernen
        work.pop_back();
        std::copy(work.begin(), work.end(), std::ostream_iterator<int>(cout,", "));
        cout << '\n';
    }

    // Heap wieder in einen sortierten Container umwandeln
    std::sort_heap(work.begin(), work.end());
    cout << "Heap in sortierten Container umgewandelt:\n";
    std::copy(work.begin(), work.end(), std::ostream_iterator<int>(cout,", "));
    cout << endl;
}
ProgrammausgabeContainer-Inhalt:
41, 67, 34, 0, 69, 24, 78, 58, 62, 64,
Fallend sortiert:
78, 69, 67, 64, 62, 58, 41, 34, 24, 0,
Vier Elemente sortiert:
0, 24, 34, 41, 69, 67, 78, 58, 62, 64,
Die vier kleinsten Elemente an den Anfang:
0, 24, 34, 41, 58, 62, 64, 67, 69, 78,
Nach der Umwandlung in einen Heap:
78, 69, 41, 62, 67, 24, 34, 58, 0, 64,
3 groessten Elemente vom Heap holen:
--> 78
69, 67, 41, 62, 64, 24, 34, 58, 0,
--> 69
67, 64, 41, 62, 0, 24, 34, 58,
--> 67
64, 62, 41, 58, 0, 24, 34,
Heap in sortierten Container umgewandelt:
0, 24, 34, 41, 58, 62, 64,

Algorithmen für sortierte Bereiche

Folgende spezielle Algorithmen stehen für sortierte Bereiche zur Verfügung:

Algorithmus Beschreibung
binary_search() Durchsucht einen Bereich nach einem bestimmten Wert
includes() Überprüft ob alle Elemente eines Bereichs in einem anderen Bereich vorkommen
lower_bound() Sucht nach dem ersten Element das größer/gleich einem bestimmten Wert ist
upper_bound() Sucht nach dem ersten Element das größer einem bestimmten Wert ist
equal_range() Kombination aus lower_bound() und upper_bound()
merge() Fügt Elemente aus zwei Bereichen zusammen
set_union() Bildet aus zwei Bereichen die Vereinigungsmenge
set_intersection() Bildet aus zwei Bereichen die Schnittmenge
set_difference() Bildet aus zwei Bereichen die Differenzmenge
set_symmetric_difference() Verodert zwei Bereich exklusiv, d.h. es werden nur die Elemente übernommen die nicht im ersten und zweiten Bereich vorkommen.
inplace_merge() Fügt zwei sortierte Teilbereiche in einem Container zusammen

Beispiel zu den Algorithmen für sortierte Bereiche

PgmHeader// Beispiel zu  Algorithmen
// Algorithmen auf sortierende Bereiche


#include <iostream>
// Algorithmen einbinden
#include <algorithm>
// ostream_iterator einbinden
#include <iterator>
// vordefinierte Functors einbinden
#include <functional>
// Container einbinden
#include <vector>
using std::cout;
using std::endl;

int main()
{
    // Container definieren
    using cType = std::vector<int>;
    cType cont1, cont2, work;
    // Container mit Zufallszahlen initialisieren
    std::generate_n(std::back_inserter(cont1), 10, rand);
    std::generate_n(std::back_inserter(cont2), 10, rand);
    // Zufallszahlen auf den Bereich 0...19 begrenzen
    // mit Hilfe von bind2nd

    std::transform(cont1.begin(), cont1.end(), cont1.begin(),
                   std::bind2nd(std::modulus<int>(), 20));
    // und jetzt mit Hilfe einer Lamdba-Funktion
    std::transform(cont2.begin(), cont2.end(), cont2.begin(),
                   [](int val)
                   {
                       return val%20;
                   });
    // Container sortieren
    std::sort(cont1.begin(),cont1.end());
    std::sort(cont2.begin(),cont2.end());
    cout << "Inhalt Container1:\n";
    std::copy(cont1.begin(), cont1.end(), std::ostream_iterator<int>(cout,", "));
    cout << '\n';
    cout << "Inhalt Container2:\n";
    std::copy(cont2.begin(), cont2.end(), std::ostream_iterator<int>(cout,", "));
    cout << '\n';

    // Abprüfen, ob alle Elemente des Containers array1 im Container1
    // enthalten sind. Das Beispiel zeigt auch auf, dass Algorithmen auch
    // auf 'normale' Felder anwendbar sind, da sich diese prinzipiell wie
    // Vektoren verhalten

    int array1[] {1,5};
    auto result = std::includes(cont1.begin(), cont1.end(),
                           array1,array1+sizeof(array1)/sizeof(int));
    if (result)
        cout << "Die Zahlen 1 und 5 sind im Container1 enthalten\n";
    else
        cout << "Die Zahlen 1 und 5 sind nicht im Container1 enthalten\n";

    // Container1 und Container2 zusammenfügen
    std::merge(cont1.begin(),cont1.end(), cont2.begin(), cont2.end(),
               std::back_inserter(work));
    cout << "Container1 und Container2 zusammengefuegt:\n";
    std::copy(work.begin(), work.end(), std::ostream_iterator<int>(cout,", "));
    cout << '\n';

    // Vereinigungsmenge zweier Container bilden
    // Hinweis: Sind mehrfach gleiche Werte in einem Container enthalten, dann
    // werden diese auch mehrfach übernommen

    work.clear();
    std::set_union(cont1.begin(),cont1.end(), cont2.begin(), cont2.end(),
                   std::back_inserter(work));
    cout << "Vereinigungsmenge aus Container1 und Container2:\n";
    std::copy(work.begin(), work.end(), std::ostream_iterator<int>(cout,", "));
    cout << '\n';

    // Schnittmenge zweier Container bilden
    work.clear();
    std::set_intersection(cont1.begin(),cont1.end(), cont2.begin(), cont2.end(),
                          std::back_inserter(work));
    cout << "Schnittmenge aus Container1 und Container2:\n";
    std::copy(work.begin(), work.end(), std::ostream_iterator<int>(cout,", "));
    cout << '\n';

    // Differenzmenge zweier Container bilden
    work.clear();
    std::set_difference(cont1.begin(),cont1.end(), cont2.begin(), cont2.end(),
                        std::back_inserter(work));
    cout << "Differenzmenge aus Container1 und Container2:\n";
    std::copy(work.begin(), work.end(), std::ostream_iterator<int>(cout,", "));
    cout << '\n';

    // Exclusive-Verorderung zweier Container bilden
    work.clear();
    std::set_symmetric_difference(cont1.begin(),cont1.end(), cont2.begin(), cont2.end(),
                                  std::back_inserter(work));
    cout << "Exclusiv-Veroderung der Container1 und Container2:\n";
    std::copy(work.begin(), work.end(), std::ostream_iterator<int>(cout,", "));
    cout << '\n';

    // Zwei sortierte Teilbereiche zusammenfügen
    // Der erste sortierte Teilbereich umfasst den Bereich [0..3]
    // und der zweite Teilbereich den Bereich [4..7]

    int array2[] {1,3,6,9,2,3,4,5};
    std::inplace_merge(array2, array2+4, array2+8);
    cout << "Zwei Teilbereiche zusammengefuegt:\n";
    std::copy(array2, array2+8, std::ostream_iterator<int>(cout,", "));
    cout << '\n';
}
ProgrammausgabeInhalt Container1:
0, 1, 2, 4, 4, 7, 9, 14, 18, 18,
Inhalt Container2:
1, 1, 2, 5, 5, 7, 7, 11, 15, 16,
Die Zahlen 1 und 5 sind nicht im Container1 enthalten
Container1 und Container2 zusammengefuegt:
0, 1, 1, 1, 2, 2, 4, 4, 5, 5, 7, 7, 7, 9, 11, 14, 15, 16, 18, 18,
Vereinigungsmenge aus Container1 und Container2:
0, 1, 1, 2, 4, 4, 5, 5, 7, 7, 9, 11, 14, 15, 16, 18, 18,
Schnittmenge aus Container1 und Container2:
1, 2, 7,
Differenzmenge aus Container1 und Container2:
0, 4, 4, 9, 14, 18, 18,
Exclusiv-Veroderung der Container1 und Container2:
0, 1, 4, 4, 5, 5, 7, 9, 11, 14, 15, 16, 18, 18,
Zwei Teilbereiche zusammengefuegt:
1, 2, 3, 3, 4, 5, 6, 9,

Numerische Algorithmen

Folgende numerische Algorithmen stehen zur Verfügung:

Algorithmus Bedeutung
accumulate() Führt Berechnungen über alle Elemente eines Bereichs aus (Standard: Addition der Elemente)
adjacent_difference() Führt Berechnungen mit benachbarten Elementen eines Bereichs durch (Standard: Differenzbildung)
inner_product() Führt Berechnungen über alle Elemente aus zwei Bereichen durch (Standard: Multiplikation der Elemente)
partial_sum() Führt eine fortlaufende Berechnung mit allen Elemente eines Bereichs durch (Standard: fortlaufende Summe)

Für alle numerischen Algorithmen gilt: Die durchzuführende Operation kann durch eine entsprechende binäre Operation, wie z.B. std::multiplies<>, angegeben werden. Der generelle Unterschied zwischen den Algorithmen liegt in der Art, wie die Elemente miteinander über die Operation verknüpft werden:

mit ex gleich x-tes Element, contx gleich Container x und op gleich Operation.

Beispiel zu den numerischen Algorithmen

PgmHeader// Beispiel zu Algorithmen
// Numerische Algorithmen


#include <iostream>
// Algorithmen einbinden
#include <algorithm>
#include <numeric>
// ostream_iterator einbinden
#include <iterator>
// vordefinierte Functors einbinden
#include <functional>
// Container einbinden
#include <vector>
using std::cout;
using std::endl;

// Functor fuer accumulate()
struct CountEven
{
    // actVal: bisheriges Ergebnis von accumulate()
    // element: Element für weitere Berechnung

    int operator()(int& actVal, int element)
    {
        // Wenn Element-Wert geradzahlig ist, dann bisheriges
        // Ergebnis von accumulate() inkrementieren

        return (element%2)? actVal: ++actVal;
    }
};

int main()
{
    // Container definieren
    using cType = std::vector<int>;
    cType cont1, cont2, work;
    // Container mit Zufallszahlen initialisieren
    std::generate_n(std::back_inserter(cont1), 10, rand);
    std::generate_n(std::back_inserter(cont2), 10, rand);
    // Zufallszahlen auf den Bereich 0...19 begrenzen
    std::transform(cont1.begin(), cont1.end(), cont1.begin(),
                   std::bind2nd(std::modulus<int>(), 20));
    std::transform(cont2.begin(), cont2.end(), cont2.begin(),
                   std::bind2nd(std::modulus<int>(), 20));
    cout << "Inhalt Container1:\n";
    std::copy(cont1.begin(), cont1.end(), std::ostream_iterator<int>(cout,", "));
    cout << '\n';
    cout << "Inhalt Container2:\n";
    std::copy(cont2.begin(), cont2.end(), std::ostream_iterator<int>(cout,", "));
    cout << endl;

    // Summe der Werte im Container1 bilden
    int result;
    result = std::accumulate(cont1.begin(), cont1.end(), 0);
    cout << "Summe der Elemente im Container1: " << result << endl;

    // Anzahl der geradzahligen Werte im Container1 ermitteln
    // Functor CountEven() testet auf Geradzahligkeit und
    // inkrementiert dann den aktuellen accumulate()-Wert

    result = std::accumulate(cont1.begin(), cont1.end(), 0, CountEven());
    cout << "Anzahl der geraden Werte: " << result << endl;

    // Differenzen der benachbarten Container1-Elemente bilden und diese dann
    // im Container work ablegen

    std::adjacent_difference(cont1.begin(), cont1.end(), std::back_inserter(work));
    cout << "Differenzen der Container1 Elemente:\n";
    std::copy(work.begin(), work.end(), std::ostream_iterator<int>(cout,", "));
    cout << endl;

    // Produkte der benachbarten Container1-Elemente bilden und diese ebenfalls
    // im Container work ablegen

    work.clear();
    std::adjacent_difference(cont1.begin(), cont1.end(),
                             std::back_inserter(work),std::multiplies<int>());
    cout << "Produkt der benachbarten Container1 Elemente:\n";
    std::copy(work.begin(), work.end(), std::ostream_iterator<int>(cout,", "));
    cout << endl;

    // Bilde die Summe aus allen Produkten der Elemente cont1e(n) * cont2e(n)
    result = std::inner_product(cont1.begin(), cont1.end(), cont2.begin(),0);
    cout << "Summe der Produkte der Container1 und Container2 Elemente: "
         << result << endl;

    // Bilde das Produkt aus der Summe der Elemente cont1e(n) + cont2e(n)
    result = std::inner_product(cont1.begin(), cont1.end(), cont2.begin(),1,
                                std::multiplies<int>(),
                                std::plus<int>());
    cout << "Produkt der Summen der Container1 und Container2 Elemente: "
         << result << endl;

    // Fortlaufende Summen über alle Container1-Elemente bilden und die
    // Summen im Container work ablegen

    work.clear();
    std::partial_sum(cont1.begin(), cont1.end(), std::back_inserter(work));
    cout << "Fortlaufende Summen der Container1 Elemente:\n";
    std::copy(work.begin(), work.end(), std::ostream_iterator<int>(cout,", "));
    cout << endl;

    // Container work mit fortlaufenden Werten füllen
    // Dazu erst einmal Container work mit '1' füllen

    std::fill(work.begin(), work.end(), 1);
    // Und nun fortlaufende Summen ebenfalls im Container work ablegen
    std::partial_sum(work.begin(), work.end(), work.begin());
    cout << "Fortlaufende Summen der Elemente:\n";
    std::copy(work.begin(), work.end(), std::ostream_iterator<int>(cout,", "));
    cout << endl;
}
ProgrammausgabeInhalt Container1:
1, 7, 14, 0, 9, 4, 18, 18, 2, 4,
Inhalt Container2: 5, 5, 1, 7, 1, 11, 15, 2, 7, 16,
Summe der Elemente im Container1: 77
Anzahl der geraden Werte: 7
Differenzen der Container1 Elemente:
1, 6, 7, -14, 9, -5, 14, 0, -16, 2,
Produkt der benachbarten Container1 Elemente:
1, 7, 98, 0, 0, 36, 72, 324, 36, 8,
Summe der Produkte der Container1 und Container2 Elemente: 491
Produkt der Summen der Container1 und Container2 Elemente: 1575213824
Fortlaufende Summen der Container1 Elemente:
1, 8, 22, 22, 31, 35, 53, 71, 73, 77,
Fortlaufende Summen der Elemente:
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,

Auf das ansonsten folgende Beispiel und eine Übung zum Thema Algorithmen verzichten wir an dieser Stelle. Wichtig ist lediglich, dass Sie einmal gesehen haben, welchen Möglichkeiten Ihnen die Standard C++ Bibliothek bietet, damit Sie in Zukunft das Rad nicht wieder von vorne erfinden müssen.

Und jetzt viel Spaß mit der nächsten Seite!