Re: Das neue Auswendig lernen und die neuen Übungen -

So, die Tiefensuche ist schnell geklärt, ich habe mich jetzt darum gekümmert

Die Tiefensuche ist nichts anderes - als die Suche nach einem konkreten Knoten. Ich finde den Algorithmus auf wikipedia sehr anschaulich. Ich finde dazu muss man folgendes sagen.

Zunächst gibt es ja Tiefen und Breitensuche. Was ich bisher betrachtet habe, war die Breitensuche - wohl, ich erinnere mich daran nicht

1.) Die Tiefensuche an sich sucht einen einfachen Knoten 1.2.) Dazu gibt es im Baum einen einfachen Algorithmus - er ist ähnlich der ausgabe der Baumknoten.

Ich denke, dass die Tiefensuche nichts anderes tut, nur im graph.

1.3.) Der Unterschied ist gleich klar - nämlich zur Frage, wozu brauchen wir Tiefensuche - an sich eine relativ müssige Sache. Der Unterschied ist aber klar - der Algorithmus des Baums tut nicht - aber warum ist es so kompliziert einen Knoten zu finden

Ich meine, es ist der Name Tiefensuche, der mich zurück schrecken lässt - später kommt die Eulertour, ich vermute, sie sucht den einfachsten Weg - oder wenn alle Knoten begangen werden müssen, einen, der nicht alle begeht

Das klingt schon etwas würdiger. Also, wozu ist Tiefensuche gut? Der Name klingt schon so - würdig. Ich sage - es ist selbstverständlich, dass wir eine brauchen. Wir müssen auch das simple, Problem klären, wie finden wir im Graphen einen Knoten

1.4.) Natürlich unterscheidet der sich von einem Baum. Aber, was ist eigentlich das Problem? Das Problem ist, dass wir selbst, bei der Tiefensuche, nämlich dem Finden eines Knotens nicht ständig im Graph umher irren können - wir dürfen die Knoten nicht mehr als ein Mal besuchen

1.5.) Was unterscheidet den Algorithmus. Den Algorithmus unterscheidet, dass er einen Stack verwendet

2.) Was gedenke ich jetzt zu tun, wo liegt mein Anliegen

2.1.) erstens, ich werde den Algorithmus in C implementieren. Ich werde weder zunächst Python verwenden, noch Java

Ich denke, wenn der Algorithmus in C gut sitzt - dann wird er auch in Python gut sitzen

2.2.) Ich werde ihn jeden Tag neu schreiben, zunächst in C - wie ich es mit Bäumen in Java tat. Bäume sind trivial und ich kenne den Algorithmus. In Java habe ich es geübt - weil ich es zusammen mit Klassen tat

2.3.) Ich werde folgendes tun - ich werde den Algorithmus auch in dem Kurs anschauen, aber ich werde ihn in C üben, auf meine Art und Weise. Jetzt gucke ich mir den Algorithmus genauer an.

So, der Witz ist - dass ich das expand nicht gross verstehe - in dem Algorithmus von wikipedia. Ich weiss nicht was das ist. Und was ich von Anfang an weiss, als ich den ersten Algorithmus gemacht habe, mit 18. In der 11. In C - das war insertion sort oder selection sort - und - den habe ich selber implementiert. Ich denke, ich werde das jetzt hier auch so probieren.

Ich würde das expand halt so verstehen, dass es alle Nachbarknoten aussucht, insofern verstehe ich das schon. Aber ich würde mein eigenes nehmen und ich würde auch bei der Tiefensuche das ist von der Fernuni Hagen abgeschaut - würde ich ein Feld nehmen, was die Knoten markiert, das heisst, ob sie schon besucht wurden.

Ich würde das expand halt so verstehen, dass es alle Nachbarknoten aussucht, insofern verstehe ich das schon. Aber ich würde mein eigenes nehmen und ich würde auch bei der Tiefensuche das ist von der Fernuni Hagen abgeschaut - würde ich ein Feld nehmen, was die Knoten markiert, das heisst, ob sie schon besucht wurden.

Ich würde das so machen, dass ich einfach alle Nachbar Knoten nehme, dass ich die alle auf den Stack tue und zu jedem Knoten markiere, ob er besucht wurde, mit einem Wahrheitswert. Danach nehme ich die Knoten vom Stack - und - wenn ich sie runter nehme, nehme ich jeweils wieder ihre Nachbarn

Das ist Tiefen und Breitensuche in einem. Weil ich kann damit ja auch die gesamte Komponente, ab einem Knoten ausgeben

Ich probiere es mal aus.

Als, erstes nehme ich mein altes Programm.

// Das sieht so aus

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>

#define N       7

int Q [1024];
int Qtop = 0;
int Qbottom = 0;

void Qput (int v) {
    Q [Qtop] = v;
    Qtop ++;
}

int Qget (void) {
    int v = Q [Qbottom];
    Qbottom++;
return v;
}

int QIsNotEmpty () {
    return (Qbottom < Qtop);
}

void breadth_first_search (int a [N][N], int *component, int r) {
    int pred [1024];
    int w, v;
    int i = 0;

    for (i = 0;  i < 1024;  i++) {
        pred [i] = -1;
        component [i] = -1;
    }

    pred [r] = r;
    component [r] = r;
    Qput (r);
    while (QIsNotEmpty ()) {
        v = Qget ();
        printf ("%cn", v + 'a');
        for (w = 0; w < N;  w++) {
            if (a [v][w]) {
                if (pred [w] == -1) {
                    pred [w] = v;
                    component [w] = component [v];
                    Qput (w);
                }
            }
        }
    }

}

int _bfs (int a [N][N], int marked [N], int r) {
    int i;
    int retv;

    if (marked [r] == -1) {
        marked [r] = 1;
        for (i = 0;  i < N;  i++)
            if(retv = _bfs (a, marked, a [r][i]))
                printf ("%c", r+'a');
        return retv;
    }

return 0;
}

void bfs (int a [N][N], int r) {
    int i;
    int marked [N];

    for (i = 0;  i < N;  i++)
        marked [i] = -1;
    _bfs (a, marked, r);
}

void generate_adjanzenzmatrix (int a [N][N], int n) {
    int i, j;

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++) {
            a [i][j] = -1;
        }
    }

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++) {
            if ((a [i][j] == -1) \&amp;\&amp; (a [j][i] == -1)) {
                a[j][i] = a [i][j] = rand () % 2;
            }
        }
    }
}

void print_csv_adjanzenzmatrix (int a [N][N], int n) {
    int i, j;

    printf ("%c,", ' ');
    for (i = 0;  i < n-1;  i++)
        printf ("%c,", i + 'a');
    printf ("%cn", i+'a');
    for (i = 0;  i < n;  i++) {
        printf ("%c,", i+'a');
        for (j = 0;  j < n-1;  j++) {
            printf ("%c,", a [i][j] + '0');
        }
        printf ("%cn", a [i][j] + '0');
    }
}

void read_csv_adjanzenzmatrix (int a [N][N], int n) {
    int i, j;
    int ch;

    scanf ("%c,", \&amp;ch);
    for (i = 0;  i < n-1;  i++)  {
        scanf ("%c,", \&amp;ch);
    }
    scanf ("%cn", \&amp;ch);

    for (i = 0;  i < n;  i++) {
        scanf ("%c,", \&amp;ch);
        for (j = 0;  j < n-1; j++) {
            scanf ("%i,", \&amp;ch);
            a [i] [j] = ch;
        }
        scanf ("%in", \&amp;ch);
        a [i] [j] = ch;
    }

}

void convert_csv_adjanzenzmatrix_to_adjazensliste (int a [N][N], int b [N][N], int n) {
    int i, j, k;

    for (i = 0;  i < n;  i++) {
        for (j = 0, k = 0;  j < n;  j++) {
            if (a [i][j] == 1) {
                b [i][k] = j;
                k++;
            }
        }
        for (; k < n;  k++)
            b [i][k] = -1;
    }

}

void convert_csv_adjanzenzliste_to_adjazensmatrix (int a [N][N], int b [N][N], int n) {
    int i, j;

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++)
            a [i][j] = 0;
    }

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++)
            if (b [i][j] != -1)
                a [i][b[i][j]] = 1;
    }

}

void read_csv_adjanzenzliste (int b [N][N], int n) {
    int i, j, k;
    int ch = 0;

    scanf ("%c,", \&amp;ch);
    for (i = 0;  i < n-1;  i++)  {
        scanf ("%c,", \&amp;ch);
    }
    scanf ("%cn", \&amp;ch);

    for (i = 0;  i < n;  i++) {
        scanf ("%c,", \&amp;ch);
        for (j = 0, k = 0;  j < n-1;  j++) {
            scanf ("%c,", \&amp;ch);
            if (ch == ' ')
                b [i][j] = -1;
            else
                b [i][j] = ch - 'a';

        }
        scanf ("%cn", \&amp;ch);
        if (ch == ' ')
            b [i][j] = -1;
        else
            b [i][j] = ch - 'a';
    }
}

void print_csv_adjanzenzliste (int b [N][N], int n) {
    int i, j;
    printf ("%c,", ' ');
    for (i = 0;  i < n-1;  i++)
        printf ("%c,", i + 'a');
    printf ("%cn", i+'a');
    for (i = 0;  i < n;  i++) {
        printf ("%c,", i+'a');
        for (j = 0;  j < n-1;  j++) {
            if (b [i][j] != -1)
                printf ("%c,", b [i][j] + 'a');
            else
                printf (" ,");
        }
        if (b [i][j] != -1)
            printf ("%cn", b [i][j] + 'a');
        else
            printf (" n");
    }

}

void print_tex (int a [N][N], int component [1024]) {
    int i, j;
    int codez = 8;
    printf("\documentclass{article}n");
    printf("\usepackage[utf8]{inputenc}n");
    printf("\usepackage{pgf, tikz}n");
    printf("\usetikzlibrary{arrows , automata , positioning}n");
    printf("\begin{document}nn");

    printf("\begin{center}n");
    printf("\begin{tikzpicture}[>=stealth',shorten >=1pt,auto,node distance=2.5cm]n");
    printf("%Knotenn");

    printf("\node (a) [state, thick] {a};n");
    printf("\node (b) [state, thick, right of= a, below of=a] {b};n");
    printf("\node (c) [state, thick, left of= a, below of=a] {c};n");
    printf("\node (d) [state, thick, below of=b, right of=b] {d};nn");
    printf("\node (e) [state, thick, below of=c, left of=c] {e};nn");

    printf("\node (g) [state, thick, below of=d, left of=d] {g};nn");
    printf("\node (f) [state, thick, below of=e, right of=e] {f};nn");

    printf("%Verbindungenn");
    printf("\path[thick,->]n");

    char *leftright [] = {"left", "right"};
    char *abovebelow [] = {"above", "below"};

    for (i = 0;  i < N;  i++) {
        for (j = 0;  j < N; j++) {
            if (a [i] [j] == 1)
                printf ("(%c) edge [bend angle=20, bend left,below] (%c)n", (char)('a' + i), (char)('a' + j));
        }
    }
    for (i = 0;  i < N-1;  i++)
        printf ("(%c) edge [bend angle=20, bend left,below, style thick] (%c)n", component [i] + 'a', component [i+1] + 'a');
    printf(";n");
    printf("\end{tikzpicture}n");
    printf("\end{center}n");
    printf("\end{document}n");

}

int main (int argc, char *argv []) {
    time_t t;
    int n = N;
    int a [N][N];
    int b [N][N];
    int component [1024];

    srand ((unsigned) time (\&amp;t));

    if (argc != 3) {
        printf ("Wrong Parameter!ng: generete generate_adjanzenzmatrixnr: read_csv_adjanzenzmatrixns: read_csv_adjanzenzlistennp: print_csv_adjanzenzmatrixnq: print_csv_adjanzenzliste");
        return 1;
    }
    if (strcmp(argv [1], "r") == 0) {
        read_csv_adjanzenzmatrix (a, n);
        convert_csv_adjanzenzmatrix_to_adjazensliste (a, b, n);
    }
    else if (strcmp (argv [1], "g") == 0) {
        generate_adjanzenzmatrix (a, n);
        convert_csv_adjanzenzmatrix_to_adjazensliste (a, b, n);
    }
    else if (strcmp (argv [1], "s") == 0) {
        read_csv_adjanzenzliste (b, n);
        convert_csv_adjanzenzliste_to_adjazensmatrix (a, b, n);
    }
    else
        printf ("Wrong Parameter!ng: generete generate_adjanzenzmatrixnr: read_csv_adjanzenzmatrixns: read_csv_adjanzenzlistennp: print_csv_adjanzenzmatrixnq: print_csv_adjanzenzliste");

    bfs (a, 0);
    if (strcmp (argv [2], "p") == 0)
        print_csv_adjanzenzmatrix (a, n);
    else if (strcmp (argv [2], "q") == 0)
        print_csv_adjanzenzliste (b, n);
    else if (strcmp (argv [2], "t") == 0)
        print_tex (a, component);

return 0;
}

Da sind noch alte - funktionen drin, für die Übersetzung von Python nach C - mit der Tiefensuche. Ich denke, dass das expand ausmacht, ich nenne es neighbours es wird einfach eine Funktion geschrieben, die lässt sich mit der Adjanzenzmatrix auch ausserhalb der Tiefensuche verwenden, die alle Nachbarn rausfischt, das mache ich mal jetzt

Die gibt einfach ein Array zurück. Bei mir ist das üblich mit Arrays zu arbeiten.

Ach, so, statt dem Stack kann ich auch die Schlange nehme, aber ich glaube in dem Falle ist das egal, bei der Tiefensuche zumindest, so wie ich das mache. Aber ich nehme die Schlange.

So, dann schreibe ich eine Funktion

 ()

rekursiv benutzt wird, dann benutze ich unter Umständen die selbe globale Variable.

# Also, neighbour () funktioniert gut

david@laptop-peaq:~\$ ./a.out g p
 ,a,b,c,d,e,f,g
a,0,0,1,1,0,0,0
b,0,0,0,1,0,0,0
c,1,0,0,1,0,1,1
d,1,1,1,1,1,0,1
e,0,0,0,1,1,0,0
f,0,0,1,0,0,0,1
g,0,0,1,1,0,1,0
2, 3,
3,
0, 3, 5, 6,
0, 1, 2, 3, 4, 6,
3, 4,
2, 6,
2, 3, 5,
david@laptop-peaq:~\$

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>

#define N       7

int Q [1024];
int Qtop = 0;
int Qbottom = 0;

void Qput (int v) {
    Q [Qtop] = v;
    Qtop ++;
}

int Qget (void) {
    int v = Q [Qbottom];
    Qbottom++;
return v;
}

int QIsNotEmpty () {
    return (Qbottom < Qtop);
}

int neighbours_index [N];

void init_neighbours_index () {
    int i;

    for (i = 0;  i < N;  i++)
        neighbours_index [i] = 0;
return;
}

void reset_neighbours_index (int i) {
    neighbours_index [i] = 0;
}

int neighbours_adjazenzmatrix (int a [N][N], int b [N], int v) {
    int i, j;

    for (i = 0, j = 0;  i < N;  i++) {
        if (a [v][i] != -1) {
            b [j] = a [v][i];
            j++;
        }
    }
return j;
}

int neighbour_adjazenzmatrix (int a [N][N], int v) {
    int t;

    while (neighbours_index [v] < N) {
        if (a [v][neighbours_index [v]] != 0) {
            t = neighbours_index [v];
            neighbours_index [v]++;
            return t;
        }
        neighbours_index [v]++;
    }
return -1;
}

void generate_adjanzenzmatrix (int a [N][N], int n) {
    int i, j;

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++) {
            a [i][j] = -1;
        }
    }

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++) {
            if ((a [i][j] == -1) \&amp;\&amp; (a [j][i] == -1)) {
                a[j][i] = a [i][j] = rand () % 2;
            }
        }
    }
}

void print_csv_adjanzenzmatrix (int a [N][N], int n) {
    int i, j;

    printf ("%c,", ' ');
    for (i = 0;  i < n-1;  i++)
        printf ("%c,", i + 'a');
    printf ("%cn", i+'a');
    for (i = 0;  i < n;  i++) {
        printf ("%c,", i+'a');
        for (j = 0;  j < n-1;  j++) {
            printf ("%c,", a [i][j] + '0');
        }
        printf ("%cn", a [i][j] + '0');
    }
}

void read_csv_adjanzenzmatrix (int a [N][N], int n) {
    int i, j;
    int ch;

    scanf ("%c,", \&amp;ch);
    for (i = 0;  i < n-1;  i++)  {
        scanf ("%c,", \&amp;ch);
    }
    scanf ("%cn", \&amp;ch);

    for (i = 0;  i < n;  i++) {
        scanf ("%c,", \&amp;ch);
        for (j = 0;  j < n-1; j++) {
            scanf ("%i,", \&amp;ch);
            a [i] [j] = ch;
        }
        scanf ("%in", \&amp;ch);
        a [i] [j] = ch;
    }

}

void convert_csv_adjanzenzmatrix_to_adjazensliste (int a [N][N], int b [N][N], int n) {
    int i, j, k;

    for (i = 0;  i < n;  i++) {
        for (j = 0, k = 0;  j < n;  j++) {
            if (a [i][j] == 1) {
                b [i][k] = j;
                k++;
            }
        }
        for (; k < n;  k++)
            b [i][k] = -1;
    }

}

void convert_csv_adjanzenzliste_to_adjazensmatrix (int a [N][N], int b [N][N], int n) {
    int i, j;

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++)
            a [i][j] = 0;
    }

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++)
            if (b [i][j] != -1)
                a [i][b[i][j]] = 1;
    }

}

void read_csv_adjanzenzliste (int b [N][N], int n) {
    int i, j, k;
    int ch = 0;

    scanf ("%c,", \&amp;ch);
    for (i = 0;  i < n-1;  i++)  {
        scanf ("%c,", \&amp;ch);
    }
    scanf ("%cn", \&amp;ch);

    for (i = 0;  i < n;  i++) {
        scanf ("%c,", \&amp;ch);
        for (j = 0, k = 0;  j < n-1;  j++) {
            scanf ("%c,", \&amp;ch);
            if (ch == ' ')
                b [i][j] = -1;
            else
                b [i][j] = ch - 'a';

        }
        scanf ("%cn", \&amp;ch);
        if (ch == ' ')
            b [i][j] = -1;
        else
            b [i][j] = ch - 'a';
    }
}

void print_csv_adjanzenzliste (int b [N][N], int n) {
    int i, j;
    printf ("%c,", ' ');
    for (i = 0;  i < n-1;  i++)
        printf ("%c,", i + 'a');
    printf ("%cn", i+'a');
    for (i = 0;  i < n;  i++) {
        printf ("%c,", i+'a');
        for (j = 0;  j < n-1;  j++) {
            if (b [i][j] != -1)
                printf ("%c,", b [i][j] + 'a');
            else
                printf (" ,");
        }
        if (b [i][j] != -1)
            printf ("%cn", b [i][j] + 'a');
        else
            printf (" n");
    }

}

void print_tex (int a [N][N], int component [1024]) {
    int i, j;
    int codez = 8;
    printf("\documentclass{article}n");
    printf("\usepackage[utf8]{inputenc}n");
    printf("\usepackage{pgf, tikz}n");
    printf("\usetikzlibrary{arrows , automata , positioning}n");
    printf("\begin{document}nn");

    printf("\begin{center}n");
    printf("\begin{tikzpicture}[>=stealth',shorten >=1pt,auto,node distance=2.5cm]n");
    printf("%Knotenn");

    printf("\node (a) [state, thick] {a};n");
    printf("\node (b) [state, thick, right of= a, below of=a] {b};n");
    printf("\node (c) [state, thick, left of= a, below of=a] {c};n");
    printf("\node (d) [state, thick, below of=b, right of=b] {d};nn");
    printf("\node (e) [state, thick, below of=c, left of=c] {e};nn");

    printf("\node (g) [state, thick, below of=d, left of=d] {g};nn");
    printf("\node (f) [state, thick, below of=e, right of=e] {f};nn");

    printf("%Verbindungenn");
    printf("\path[thick,->]n");

    char *leftright [] = {"left", "right"};
    char *abovebelow [] = {"above", "below"};

    for (i = 0;  i < N;  i++) {
        for (j = 0;  j < N; j++) {
            if (a [i] [j] == 1)
                printf ("(%c) edge [bend angle=20, bend left,below] (%c)n", (char)('a' + i), (char)('a' + j));
        }
    }
    for (i = 0;  i < N-1;  i++)
        printf ("(%c) edge [bend angle=20, bend left,below, style thick] (%c)n", component [i] + 'a', component [i+1] + 'a');
    printf(";n");
    printf("\end{tikzpicture}n");
    printf("\end{center}n");
    printf("\end{document}n");

}

int main (int argc, char *argv []) {
    time_t t;
    int n = N;
    int a [N][N];
    int b [N][N];
    int component [1024];

    srand ((unsigned) time (\&amp;t));

    if (argc != 3) {
        printf ("Wrong Parameter!ng: generete generate_adjanzenzmatrixnr: read_csv_adjanzenzmatrixns: read_csv_adjanzenzlistennp: print_csv_adjanzenzmatrixnq: print_csv_adjanzenzliste");
        return 1;
    }
    if (strcmp(argv [1], "r") == 0) {
        read_csv_adjanzenzmatrix (a, n);
        convert_csv_adjanzenzmatrix_to_adjazensliste (a, b, n);
    }
    else if (strcmp (argv [1], "g") == 0) {
        generate_adjanzenzmatrix (a, n);
        convert_csv_adjanzenzmatrix_to_adjazensliste (a, b, n);
    }
    else if (strcmp (argv [1], "s") == 0) {
        read_csv_adjanzenzliste (b, n);
        convert_csv_adjanzenzliste_to_adjazensmatrix (a, b, n);
    }
    else
        printf ("Wrong Parameter!ng: generete generate_adjanzenzmatrixnr: read_csv_adjanzenzmatrixns: read_csv_adjanzenzlistennp: print_csv_adjanzenzmatrixnq: print_csv_adjanzenzliste");

    if (strcmp (argv [2], "p") == 0)
        print_csv_adjanzenzmatrix (a, n);
    else if (strcmp (argv [2], "q") == 0)
        print_csv_adjanzenzliste (b, n);
    else if (strcmp (argv [2], "t") == 0)
        print_tex (a, component);

    int i, x;

    init_neighbours_index ();
    for (i = 0;  i < N;  i++) {
        while ((x = neighbour_adjazenzmatrix (a, i)) != -1)
            printf ("%i, ", x);
        printf ("n");
    }

return 0;
}

Im nächsten Schritt, schreibe ich erst Mal, die Tiefensuche, aber das wird auch gleich zur Breitensuche - einen Moment - ich mache das auf meine Art.

Ich mache was anderes, ich suche die Komponenten zu einem Knoten. Ich gebe den Knoten an - und dann sucht der dazu die Komponente. Den Knoten selber, den könnte ich anders finden, ich gehe einfach die komplette Adjazenzmatrix durch

Gut - aber ich mache das jetzt so - ich gehe zu einem Knoten, und gebe von dem die Komponenten aus

Mit der bisherigen Ausgabe, kann man dann einfach nachvollziehen, ob diese Komponente richtig ist.

# Ich denke, das hat funktioniert, aber ich kann die Buchstaben schlecht "uberpr"ufen, ich muss die Ausgabe "andern

david@laptop-peaq:~\$ ./a.out g p
 ,a,b,c,d,e,f,g
a,1,1,0,1,1,1,1
b,1,1,0,1,0,1,0
c,0,0,0,1,1,0,1
d,1,1,1,1,1,1,1
e,1,0,1,1,0,0,1
f,1,1,0,1,0,0,0
g,1,0,1,1,1,0,0
0, 1, 3, 4, 5, 6,
0, 1, 3, 5,
3, 4, 6,
0, 1, 2, 3, 4, 5, 6,
0, 2, 3, 6,
0, 1, 3,
0, 2, 3, 4,
0
1
3
4
5
6
2
0, 1, 3, 4, 5, 6, 2, david@laptop-peaq:~\$

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>

#define N       7

int Q [1024];
int Qtop = 0;
int Qbottom = 0;

void Qput (int v) {
    Q [Qtop] = v;
    Qtop ++;
}

int Qget (void) {
    int v = Q [Qbottom];
    Qbottom++;
return v;
}

int QIsNotEmpty () {
    return (Qbottom < Qtop);
}

int neighbours_index [N];

void init_neighbours_index () {
    int i;

    for (i = 0;  i < N;  i++)
        neighbours_index [i] = 0;
return;
}

void reset_neighbours_index (int i) {
    neighbours_index [i] = 0;
}

int neighbours_adjazenzmatrix (int a [N][N], int b [N], int v) {
    int i, j;

    for (i = 0, j = 0;  i < N;  i++) {
        if (a [v][i] != -1) {
            b [j] = a [v][i];
            j++;
        }
    }
return j;
}

int neighbour_adjazenzmatrix (int a [N][N], int v) {
    int t;

    while (neighbours_index [v] < N) {
        if (a [v][neighbours_index [v]] != 0) {
            t = neighbours_index [v];
            neighbours_index [v]++;
            return t;
        }
        neighbours_index [v]++;
    }
return -1;
}

int visited [N];

void init_visited (void) {
    int i;
    for (i = 0;  i < N;  i++)
        visited [i] = 0;
return;
}

int _bfs (int a [N][N], int b [N], int v, int i) {
    int w;

    Qput (v);
    while (QIsNotEmpty ()) {
        v = Qget ();
        while ((w = neighbour_adjazenzmatrix (a, v)) != -1) {
            if (visited [w] == 0) {
                visited [w] = 1;
                Qput (w);
                b [i++] = w;
                printf ("%in", w);
            }
        }
    }
}

int bfs (int a [N][N], int b [N], int v) {
    init_neighbours_index ();
    init_visited ();
    _bfs (a, b, v, 0);
}

void generate_adjanzenzmatrix (int a [N][N], int n) {
    int i, j;

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++) {
            a [i][j] = -1;
        }
    }

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++) {
            if ((a [i][j] == -1) \&amp;\&amp; (a [j][i] == -1)) {
                a[j][i] = a [i][j] = rand () % 2;
            }
        }
    }
}

void print_csv_adjanzenzmatrix (int a [N][N], int n) {
    int i, j;

    printf ("%c,", ' ');
    for (i = 0;  i < n-1;  i++)
        printf ("%c,", i + 'a');
    printf ("%cn", i+'a');
    for (i = 0;  i < n;  i++) {
        printf ("%c,", i+'a');
        for (j = 0;  j < n-1;  j++) {
            printf ("%c,", a [i][j] + '0');
        }
        printf ("%cn", a [i][j] + '0');
    }
}

void read_csv_adjanzenzmatrix (int a [N][N], int n) {
    int i, j;
    int ch;

    scanf ("%c,", \&amp;ch);
    for (i = 0;  i < n-1;  i++)  {
        scanf ("%c,", \&amp;ch);
    }
    scanf ("%cn", \&amp;ch);

    for (i = 0;  i < n;  i++) {
        scanf ("%c,", \&amp;ch);
        for (j = 0;  j < n-1; j++) {
            scanf ("%i,", \&amp;ch);
            a [i] [j] = ch;
        }
        scanf ("%in", \&amp;ch);
        a [i] [j] = ch;
    }

}

void convert_csv_adjanzenzmatrix_to_adjazensliste (int a [N][N], int b [N][N], int n) {
    int i, j, k;

    for (i = 0;  i < n;  i++) {
        for (j = 0, k = 0;  j < n;  j++) {
            if (a [i][j] == 1) {
                b [i][k] = j;
                k++;
            }
        }
        for (; k < n;  k++)
            b [i][k] = -1;
    }

}

void convert_csv_adjanzenzliste_to_adjazensmatrix (int a [N][N], int b [N][N], int n) {
    int i, j;

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++)
            a [i][j] = 0;
    }

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++)
            if (b [i][j] != -1)
                a [i][b[i][j]] = 1;
    }

}

void read_csv_adjanzenzliste (int b [N][N], int n) {
    int i, j, k;
    int ch = 0;

    scanf ("%c,", \&amp;ch);
    for (i = 0;  i < n-1;  i++)  {
        scanf ("%c,", \&amp;ch);
    }
    scanf ("%cn", \&amp;ch);

    for (i = 0;  i < n;  i++) {
        scanf ("%c,", \&amp;ch);
        for (j = 0, k = 0;  j < n-1;  j++) {
            scanf ("%c,", \&amp;ch);
            if (ch == ' ')
                b [i][j] = -1;
            else
                b [i][j] = ch - 'a';

        }
        scanf ("%cn", \&amp;ch);
        if (ch == ' ')
            b [i][j] = -1;
        else
            b [i][j] = ch - 'a';
    }
}

void print_csv_adjanzenzliste (int b [N][N], int n) {
    int i, j;
    printf ("%c,", ' ');
    for (i = 0;  i < n-1;  i++)
        printf ("%c,", i + 'a');
    printf ("%cn", i+'a');
    for (i = 0;  i < n;  i++) {
        printf ("%c,", i+'a');
        for (j = 0;  j < n-1;  j++) {
            if (b [i][j] != -1)
                printf ("%c,", b [i][j] + 'a');
            else
                printf (" ,");
        }
        if (b [i][j] != -1)
            printf ("%cn", b [i][j] + 'a');
        else
            printf (" n");
    }

}

void print_tex (int a [N][N], int component [1024]) {
    int i, j;
    int codez = 8;
    printf("\documentclass{article}n");
    printf("\usepackage[utf8]{inputenc}n");
    printf("\usepackage{pgf, tikz}n");
    printf("\usetikzlibrary{arrows , automata , positioning}n");
    printf("\begin{document}nn");

    printf("\begin{center}n");
    printf("\begin{tikzpicture}[>=stealth',shorten >=1pt,auto,node distance=2.5cm]n");
    printf("%Knotenn");

    printf("\node (a) [state, thick] {a};n");
    printf("\node (b) [state, thick, right of= a, below of=a] {b};n");
    printf("\node (c) [state, thick, left of= a, below of=a] {c};n");
    printf("\node (d) [state, thick, below of=b, right of=b] {d};nn");
    printf("\node (e) [state, thick, below of=c, left of=c] {e};nn");

    printf("\node (g) [state, thick, below of=d, left of=d] {g};nn");
    printf("\node (f) [state, thick, below of=e, right of=e] {f};nn");

    printf("%Verbindungenn");
    printf("\path[thick,->]n");

    char *leftright [] = {"left", "right"};
    char *abovebelow [] = {"above", "below"};

    for (i = 0;  i < N;  i++) {
        for (j = 0;  j < N; j++) {
            if (a [i] [j] == 1)
                printf ("(%c) edge [bend angle=20, bend left,below] (%c)n", (char)('a' + i), (char)('a' + j));
        }
    }
    for (i = 0;  i < N-1;  i++)
        printf ("(%c) edge [bend angle=20, bend left,below, style thick] (%c)n", component [i] + 'a', component [i+1] + 'a');
    printf(";n");
    printf("\end{tikzpicture}n");
    printf("\end{center}n");
    printf("\end{document}n");

}

int main (int argc, char *argv []) {
    time_t t;
    int n = N;
    int a [N][N];
    int b [N][N];
    int component [1024];

    srand ((unsigned) time (\&amp;t));

    if (argc != 3) {
        printf ("Wrong Parameter!ng: generete generate_adjanzenzmatrixnr: read_csv_adjanzenzmatrixns: read_csv_adjanzenzlistennp: print_csv_adjanzenzmatrixnq: print_csv_adjanzenzliste");
        return 1;
    }
    if (strcmp(argv [1], "r") == 0) {
        read_csv_adjanzenzmatrix (a, n);
        convert_csv_adjanzenzmatrix_to_adjazensliste (a, b, n);
    }
    else if (strcmp (argv [1], "g") == 0) {
        generate_adjanzenzmatrix (a, n);
        convert_csv_adjanzenzmatrix_to_adjazensliste (a, b, n);
    }
    else if (strcmp (argv [1], "s") == 0) {
        read_csv_adjanzenzliste (b, n);
        convert_csv_adjanzenzliste_to_adjazensmatrix (a, b, n);
    }
    else
        printf ("Wrong Parameter!ng: generete generate_adjanzenzmatrixnr: read_csv_adjanzenzmatrixns: read_csv_adjanzenzlistennp: print_csv_adjanzenzmatrixnq: print_csv_adjanzenzliste");

    if (strcmp (argv [2], "p") == 0)
        print_csv_adjanzenzmatrix (a, n);
    else if (strcmp (argv [2], "q") == 0)
        print_csv_adjanzenzliste (b, n);
    else if (strcmp (argv [2], "t") == 0)
        print_tex (a, component);

    int i, x;

    init_neighbours_index ();
    for (i = 0;  i < N;  i++) {
        while ((x = neighbour_adjazenzmatrix (a, i)) != -1)
            printf ("%i, ", x);
        printf ("n");
    }

    int c [N];

    bfs (a, c, 0);

    for (i = 0;  i < N;  i++)
        printf ("%i, ", c [i]);

return 0;
}

# Ich verstehe, gucken sie mal das an
# Der Witz ist ja - sie k"onnen einen durchgehenden Pfad machen, das ist Weg - das heisst, wenn sie von a einen Knoten nach b haben und von da aus nach d - dann k"onnte ja trotzdem einer von a nach d f"uhren. Sie w"urden aber, den sagen wir "g"unstigen" Pfad nehmen, also weg - von a - b - d - aber, es kann ja auch sein, dass sie einen Baum erzeugen. Und nichts anderes "ubrig bleibt

# Weil es kann ja sein, dass nur von c nach d ein weg f"uhrt. Aber - hinter d kommen weitere Knoten, die sie von aus erreichen. Aber von d f"uhrt keiner zu den weiteren

# Das heisst, es kann so oder so ein Baum herauskommen und die Aufgabe, dass ein "g"unstiger" Pfad gesucht wird, ist eine spezielle Aufgabe, aber gar nicht unbedingt immer m"oglich

david@laptop-peaq:~\$ ./a.out g p
 ,a,b,c,d,e,f,g
a,1,0,1,1,0,0,0
b,0,1,1,0,1,1,1
c,1,1,0,0,0,0,0
d,1,0,0,1,1,0,0
e,0,1,0,1,1,1,1
f,0,1,0,0,1,1,1
g,0,1,0,0,1,1,0
0, 2, 3,
1, 2, 4, 5, 6,
0, 1,
0, 3, 4,
1, 3, 4, 5, 6,
1, 4, 5, 6,
1, 4, 5,
0
2
3
1
4
5
6
a, c, d, b, e, f, g, david@laptop-peaq:~\$

Dann muss man das anders machen, man muss vor den neighbour - die ja alle durchgegangen werden, gleich davor Qput aufrufen, das günstigste wäre hier eine Rekursion zu nehmen.

# Also, das Programm funktioniert jetzt - rekursiv - mit dem Bestm"oglichen Pfad

david@laptop-peaq:~\$ ./a.out g p
 ,a,b,c,d,e,f,g
a,1,0,0,0,1,0,0
b,0,1,1,1,1,0,1
c,0,1,1,1,0,1,0
d,0,1,1,1,0,0,0
e,1,1,0,0,1,0,0
f,0,0,1,0,0,1,0
g,0,1,0,0,0,0,1
0, 4,
1, 2, 3, 4, 6,
1, 2, 3, 5,
1, 2, 3,
0, 1, 4,
2, 5,
1, 6,
d, f, c, g, b, e,
a, e, b, c, d, f, g, david@laptop-peaq:~\$

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>

#define N       7

int Q [1024];
int Qtop = 0;
int Qbottom = 0;

void Qput (int v) {
    Q [Qtop] = v;
    Qtop ++;
}

int Qget (void) {
    int v = Q [Qbottom];
    Qbottom++;
return v;
}

int QIsNotEmpty () {
    return (Qbottom < Qtop);
}

int neighbours_index [N];

void init_neighbours_index () {
    int i;

    for (i = 0;  i < N;  i++)
        neighbours_index [i] = 0;
return;
}

void reset_neighbours_index (int i) {
    neighbours_index [i] = 0;
}

int neighbours_adjazenzmatrix (int a [N][N], int b [N], int v) {
    int i, j;

    for (i = 0, j = 0;  i < N;  i++) {
        if (a [v][i] != -1) {
            b [j] = a [v][i];
            j++;
        }
    }
return j;
}

int neighbour_adjazenzmatrix (int a [N][N], int v) {
    int t;

    while (neighbours_index [v] < N) {
        if (a [v][neighbours_index [v]] != 0) {
            t = neighbours_index [v];
            neighbours_index [v]++;
            return t;
        }
        neighbours_index [v]++;
    }
return -1;
}

int visited [N];

void init_visited (void) {
    int i;
    for (i = 0;  i < N;  i++)
        visited [i] = 0;
return;
}

int notAllVisited () {
    int i;

    for (i = 0;  i < N;  i++)
        if (visited [i] == 0)
            return 1;
return 0;
}

int ix;

int _bfs (int a [N][N], int b [N], int v) {
    int w;

    if (notAllVisited ()) {
        while ((w = neighbour_adjazenzmatrix (a, v)) != -1) {
            if (visited [w] == 0) {
                visited [w] = 1;
                b [ix] = w;
                ix++;
                _bfs (a, b, w);
                printf ("%c, ", w + 'a');
            }
        }
    }
}

int bfs (int a [N][N], int b [N], int v) {
    init_neighbours_index ();
    init_visited ();
    visited [v] = 1;
    ix = 0;
    b [ix] = v;
    ix = 1;
    _bfs (a, b, v);
    printf ("n");
}

void generate_adjanzenzmatrix (int a [N][N], int n) {
    int i, j;

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++) {
            a [i][j] = -1;
        }
    }

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++) {
            if ((a [i][j] == -1) \&amp;\&amp; (a [j][i] == -1)) {
                a[j][i] = a [i][j] = rand () % 2;
            }
            if (i == j)
                a [i][j] = a [j][i] = 1;

        }
    }
}

void print_csv_adjanzenzmatrix (int a [N][N], int n) {
    int i, j;

    printf ("%c,", ' ');
    for (i = 0;  i < n-1;  i++)
        printf ("%c,", i + 'a');
    printf ("%cn", i+'a');
    for (i = 0;  i < n;  i++) {
        printf ("%c,", i+'a');
        for (j = 0;  j < n-1;  j++) {
            printf ("%c,", a [i][j] + '0');
        }
        printf ("%cn", a [i][j] + '0');
    }
}

void read_csv_adjanzenzmatrix (int a [N][N], int n) {
    int i, j;
    int ch;

    scanf ("%c,", \&amp;ch);
    for (i = 0;  i < n-1;  i++)  {
        scanf ("%c,", \&amp;ch);
    }
    scanf ("%cn", \&amp;ch);

    for (i = 0;  i < n;  i++) {
        scanf ("%c,", \&amp;ch);
        for (j = 0;  j < n-1; j++) {
            scanf ("%i,", \&amp;ch);
            a [i] [j] = ch;
        }
        scanf ("%in", \&amp;ch);
        a [i] [j] = ch;
    }

}

void convert_csv_adjanzenzmatrix_to_adjazensliste (int a [N][N], int b [N][N], int n) {
    int i, j, k;

    for (i = 0;  i < n;  i++) {
        for (j = 0, k = 0;  j < n;  j++) {
            if (a [i][j] == 1) {
                b [i][k] = j;
                k++;
            }
        }
        for (; k < n;  k++)
            b [i][k] = -1;
    }

}

void convert_csv_adjanzenzliste_to_adjazensmatrix (int a [N][N], int b [N][N], int n) {
    int i, j;

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++)
            a [i][j] = 0;
    }

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++)
            if (b [i][j] != -1)
                a [i][b[i][j]] = 1;
    }

}

void read_csv_adjanzenzliste (int b [N][N], int n) {
    int i, j, k;
    int ch = 0;

    scanf ("%c,", \&amp;ch);
    for (i = 0;  i < n-1;  i++)  {
        scanf ("%c,", \&amp;ch);
    }
    scanf ("%cn", \&amp;ch);

    for (i = 0;  i < n;  i++) {
        scanf ("%c,", \&amp;ch);
        for (j = 0, k = 0;  j < n-1;  j++) {
            scanf ("%c,", \&amp;ch);
            if (ch == ' ')
                b [i][j] = -1;
            else
                b [i][j] = ch - 'a';

        }
        scanf ("%cn", \&amp;ch);
        if (ch == ' ')
            b [i][j] = -1;
        else
            b [i][j] = ch - 'a';
    }
}

void print_csv_adjanzenzliste (int b [N][N], int n) {
    int i, j;
    printf ("%c,", ' ');
    for (i = 0;  i < n-1;  i++)
        printf ("%c,", i + 'a');
    printf ("%cn", i+'a');
    for (i = 0;  i < n;  i++) {
        printf ("%c,", i+'a');
        for (j = 0;  j < n-1;  j++) {
            if (b [i][j] != -1)
                printf ("%c,", b [i][j] + 'a');
            else
                printf (" ,");
        }
        if (b [i][j] != -1)
            printf ("%cn", b [i][j] + 'a');
        else
            printf (" n");
    }

}

void print_tex (int a [N][N], int component [1024]) {
    int i, j;
    int codez = 8;
    printf("\documentclass{article}n");
    printf("\usepackage[utf8]{inputenc}n");
    printf("\usepackage{pgf, tikz}n");
    printf("\usetikzlibrary{arrows , automata , positioning}n");
    printf("\begin{document}nn");

    printf("\begin{center}n");
    printf("\begin{tikzpicture}[>=stealth',shorten >=1pt,auto,node distance=2.5cm]n");
    printf("%Knotenn");

    printf("\node (a) [state, thick] {a};n");
    printf("\node (b) [state, thick, right of= a, below of=a] {b};n");
    printf("\node (c) [state, thick, left of= a, below of=a] {c};n");
    printf("\node (d) [state, thick, below of=b, right of=b] {d};nn");
    printf("\node (e) [state, thick, below of=c, left of=c] {e};nn");

    printf("\node (g) [state, thick, below of=d, left of=d] {g};nn");
    printf("\node (f) [state, thick, below of=e, right of=e] {f};nn");

    printf("%Verbindungenn");
    printf("\path[thick,->]n");

    char *leftright [] = {"left", "right"};
    char *abovebelow [] = {"above", "below"};

    for (i = 0;  i < N;  i++) {
        for (j = 0;  j < N; j++) {
            if (a [i] [j] == 1)
                printf ("(%c) edge [bend angle=20, bend left,below] (%c)n", (char)('a' + i), (char)('a' + j));
        }
    }
    for (i = 0;  i < N-1;  i++)
        printf ("(%c) edge [bend angle=20, bend left,below, style thick] (%c)n", component [i] + 'a', component [i+1] + 'a');
    printf(";n");
    printf("\end{tikzpicture}n");
    printf("\end{center}n");
    printf("\end{document}n");

}

int main (int argc, char *argv []) {
    time_t t;
    int n = N;
    int a [N][N];
    int b [N][N];
    int component [1024];

    srand ((unsigned) time (\&amp;t));

    if (argc != 3) {
        printf ("Wrong Parameter!ng: generete generate_adjanzenzmatrixnr: read_csv_adjanzenzmatrixns: read_csv_adjanzenzlistennp: print_csv_adjanzenzmatrixnq: print_csv_adjanzenzliste");
        return 1;
    }
    if (strcmp(argv [1], "r") == 0) {
        read_csv_adjanzenzmatrix (a, n);
        convert_csv_adjanzenzmatrix_to_adjazensliste (a, b, n);
    }
    else if (strcmp (argv [1], "g") == 0) {
        generate_adjanzenzmatrix (a, n);
        convert_csv_adjanzenzmatrix_to_adjazensliste (a, b, n);
    }
    else if (strcmp (argv [1], "s") == 0) {
        read_csv_adjanzenzliste (b, n);
        convert_csv_adjanzenzliste_to_adjazensmatrix (a, b, n);
    }
    else
        printf ("Wrong Parameter!ng: generete generate_adjanzenzmatrixnr: read_csv_adjanzenzmatrixns: read_csv_adjanzenzlistennp: print_csv_adjanzenzmatrixnq: print_csv_adjanzenzliste");

    if (strcmp (argv [2], "p") == 0)
        print_csv_adjanzenzmatrix (a, n);
    else if (strcmp (argv [2], "q") == 0)
        print_csv_adjanzenzliste (b, n);
    else if (strcmp (argv [2], "t") == 0)
        print_tex (a, component);

    int i, x;

    init_neighbours_index ();
    for (i = 0;  i < N;  i++) {
        while ((x = neighbour_adjazenzmatrix (a, i)) != -1)
            printf ("%i, ", x);
        printf ("n");
    }

    int c [N];

    bfs (a, c, 0);

    for (i = 0;  i < N;  i++)
        printf ("%c, ", c [i] + 'a');

return 0;
}

david@laptop-peaq:~\$ ./a.out g p
 ,a,b,c,d,e,f,g
a,1,0,1,0,0,1,0
b,0,1,0,0,1,0,1
c,1,0,1,0,1,1,0
d,0,0,0,1,1,0,1
e,0,1,1,1,1,0,0
f,1,0,1,0,0,1,1
g,0,1,0,1,0,1,1
0, 2, 5,
1, 4, 6,
0, 2, 4, 5,
3, 4, 6,
1, 2, 3, 4,
0, 2, 5, 6,
1, 3, 5, 6,
d, f, g, b, e, c,
a, c, e, b, g, d, f, david@laptop-peaq:~\$

# So ist besser

david@laptop-peaq:~\$ ./a.out g p
 ,a,b,c,d,e,f,g
a,1,0,0,1,0,1,1
b,0,1,0,1,1,1,0
c,0,0,1,0,0,0,1
d,1,1,0,1,1,1,0
e,0,1,0,1,1,1,0
f,1,1,0,1,1,1,0
g,1,0,1,0,0,0,1
0, 3, 5, 6,
1, 3, 4, 5,
2, 6,
0, 1, 3, 4, 5,
1, 3, 4, 5,
0, 1, 3, 4, 5,
0, 2, 6,
a, d, b, e, f, g, c,
a, d, b, e, f, g, c, david@laptop-peaq:~\$

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>

#define N       7

int Q [1024];
int Qtop = 0;
int Qbottom = 0;

void Qput (int v) {
    Q [Qtop] = v;
    Qtop ++;
}

int Qget (void) {
    int v = Q [Qbottom];
    Qbottom++;
return v;
}

int QIsNotEmpty () {
    return (Qbottom < Qtop);
}

int neighbours_index [N];

void init_neighbours_index () {
    int i;

    for (i = 0;  i < N;  i++)
        neighbours_index [i] = 0;
return;
}

void reset_neighbours_index (int i) {
    neighbours_index [i] = 0;
}

int neighbours_adjazenzmatrix (int a [N][N], int b [N], int v) {
    int i, j;

    for (i = 0, j = 0;  i < N;  i++) {
        if (a [v][i] != -1) {
            b [j] = a [v][i];
            j++;
        }
    }
return j;
}

int neighbour_adjazenzmatrix (int a [N][N], int v) {
    int t;

    while (neighbours_index [v] < N) {
        if (a [v][neighbours_index [v]] != 0) {
            t = neighbours_index [v];
            neighbours_index [v]++;
            return t;
        }
        neighbours_index [v]++;
    }
return -1;
}

int visited [N];

void init_visited (void) {
    int i;
    for (i = 0;  i < N;  i++)
        visited [i] = 0;
return;
}

int notAllVisited () {
    int i;

    for (i = 0;  i < N;  i++)
        if (visited [i] == 0)
            return 1;
return 0;
}

int ix;

int _bfs (int a [N][N], int b [N], int v) {
    int w;

    printf ("%c, ", v + 'a');
    if (notAllVisited ()) {
        while ((w = neighbour_adjazenzmatrix (a, v)) != -1) {
            if (visited [w] == 0) {
                visited [w] = 1;
                b [ix] = w;
                ix++;
                _bfs (a, b, w);
            }
        }
    }
}

int bfs (int a [N][N], int b [N], int v) {
    init_neighbours_index ();
    init_visited ();
    visited [v] = 1;
    ix = 0;
    b [ix] = v;
    ix = 1;
    _bfs (a, b, v);
    printf ("n");
}

void generate_adjanzenzmatrix (int a [N][N], int n) {
    int i, j;

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++) {
            a [i][j] = -1;
        }
    }

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++) {
            if ((a [i][j] == -1) \&amp;\&amp; (a [j][i] == -1)) {
                a[j][i] = a [i][j] = rand () % 2;
            }
            if (i == j)
                a [i][j] = a [j][i] = 1;

        }
    }
}

void print_csv_adjanzenzmatrix (int a [N][N], int n) {
    int i, j;

    printf ("%c,", ' ');
    for (i = 0;  i < n-1;  i++)
        printf ("%c,", i + 'a');
    printf ("%cn", i+'a');
    for (i = 0;  i < n;  i++) {
        printf ("%c,", i+'a');
        for (j = 0;  j < n-1;  j++) {
            printf ("%c,", a [i][j] + '0');
        }
        printf ("%cn", a [i][j] + '0');
    }
}

void read_csv_adjanzenzmatrix (int a [N][N], int n) {
    int i, j;
    int ch;

    scanf ("%c,", \&amp;ch);
    for (i = 0;  i < n-1;  i++)  {
        scanf ("%c,", \&amp;ch);
    }
    scanf ("%cn", \&amp;ch);

    for (i = 0;  i < n;  i++) {
        scanf ("%c,", \&amp;ch);
        for (j = 0;  j < n-1; j++) {
            scanf ("%i,", \&amp;ch);
            a [i] [j] = ch;
        }
        scanf ("%in", \&amp;ch);
        a [i] [j] = ch;
    }

}

void convert_csv_adjanzenzmatrix_to_adjazensliste (int a [N][N], int b [N][N], int n) {
    int i, j, k;

    for (i = 0;  i < n;  i++) {
        for (j = 0, k = 0;  j < n;  j++) {
            if (a [i][j] == 1) {
                b [i][k] = j;
                k++;
            }
        }
        for (; k < n;  k++)
            b [i][k] = -1;
    }

}

void convert_csv_adjanzenzliste_to_adjazensmatrix (int a [N][N], int b [N][N], int n) {
    int i, j;

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++)
            a [i][j] = 0;
    }

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++)
            if (b [i][j] != -1)
                a [i][b[i][j]] = 1;
    }

}

void read_csv_adjanzenzliste (int b [N][N], int n) {
    int i, j, k;
    int ch = 0;

    scanf ("%c,", \&amp;ch);
    for (i = 0;  i < n-1;  i++)  {
        scanf ("%c,", \&amp;ch);
    }
    scanf ("%cn", \&amp;ch);

    for (i = 0;  i < n;  i++) {
        scanf ("%c,", \&amp;ch);
        for (j = 0, k = 0;  j < n-1;  j++) {
            scanf ("%c,", \&amp;ch);
            if (ch == ' ')
                b [i][j] = -1;
            else
                b [i][j] = ch - 'a';

        }
        scanf ("%cn", \&amp;ch);
        if (ch == ' ')
            b [i][j] = -1;
        else
            b [i][j] = ch - 'a';
    }
}

void print_csv_adjanzenzliste (int b [N][N], int n) {
    int i, j;
    printf ("%c,", ' ');
    for (i = 0;  i < n-1;  i++)
        printf ("%c,", i + 'a');
    printf ("%cn", i+'a');
    for (i = 0;  i < n;  i++) {
        printf ("%c,", i+'a');
        for (j = 0;  j < n-1;  j++) {
            if (b [i][j] != -1)
                printf ("%c,", b [i][j] + 'a');
            else
                printf (" ,");
        }
        if (b [i][j] != -1)
            printf ("%cn", b [i][j] + 'a');
        else
            printf (" n");
    }

}

void print_tex (int a [N][N], int component [1024]) {
    int i, j;
    int codez = 8;
    printf("\documentclass{article}n");
    printf("\usepackage[utf8]{inputenc}n");
    printf("\usepackage{pgf, tikz}n");
    printf("\usetikzlibrary{arrows , automata , positioning}n");
    printf("\begin{document}nn");

    printf("\begin{center}n");
    printf("\begin{tikzpicture}[>=stealth',shorten >=1pt,auto,node distance=2.5cm]n");
    printf("%Knotenn");

    printf("\node (a) [state, thick] {a};n");
    printf("\node (b) [state, thick, right of= a, below of=a] {b};n");
    printf("\node (c) [state, thick, left of= a, below of=a] {c};n");
    printf("\node (d) [state, thick, below of=b, right of=b] {d};nn");
    printf("\node (e) [state, thick, below of=c, left of=c] {e};nn");

    printf("\node (g) [state, thick, below of=d, left of=d] {g};nn");
    printf("\node (f) [state, thick, below of=e, right of=e] {f};nn");

    printf("%Verbindungenn");
    printf("\path[thick,->]n");

    char *leftright [] = {"left", "right"};
    char *abovebelow [] = {"above", "below"};

    for (i = 0;  i < N;  i++) {
        for (j = 0;  j < N; j++) {
            if (a [i] [j] == 1)
                printf ("(%c) edge [bend angle=20, bend left,below] (%c)n", (char)('a' + i), (char)('a' + j));
        }
    }
    for (i = 0;  i < N-1;  i++)
        printf ("(%c) edge [bend angle=20, bend left,below, style thick] (%c)n", component [i] + 'a', component [i+1] + 'a');
    printf(";n");
    printf("\end{tikzpicture}n");
    printf("\end{center}n");
    printf("\end{document}n");

}

int main (int argc, char *argv []) {
    time_t t;
    int n = N;
    int a [N][N];
    int b [N][N];
    int component [1024];

    srand ((unsigned) time (\&amp;t));

    if (argc != 3) {
        printf ("Wrong Parameter!ng: generete generate_adjanzenzmatrixnr: read_csv_adjanzenzmatrixns: read_csv_adjanzenzlistennp: print_csv_adjanzenzmatrixnq: print_csv_adjanzenzliste");
        return 1;
    }
    if (strcmp(argv [1], "r") == 0) {
        read_csv_adjanzenzmatrix (a, n);
        convert_csv_adjanzenzmatrix_to_adjazensliste (a, b, n);
    }
    else if (strcmp (argv [1], "g") == 0) {
        generate_adjanzenzmatrix (a, n);
        convert_csv_adjanzenzmatrix_to_adjazensliste (a, b, n);
    }
    else if (strcmp (argv [1], "s") == 0) {
        read_csv_adjanzenzliste (b, n);
        convert_csv_adjanzenzliste_to_adjazensmatrix (a, b, n);
    }
    else
        printf ("Wrong Parameter!ng: generete generate_adjanzenzmatrixnr: read_csv_adjanzenzmatrixns: read_csv_adjanzenzlistennp: print_csv_adjanzenzmatrixnq: print_csv_adjanzenzliste");

    if (strcmp (argv [2], "p") == 0)
        print_csv_adjanzenzmatrix (a, n);
    else if (strcmp (argv [2], "q") == 0)
        print_csv_adjanzenzliste (b, n);
    else if (strcmp (argv [2], "t") == 0)
        print_tex (a, component);

    int i, x;

    init_neighbours_index ();
    for (i = 0;  i < N;  i++) {
        while ((x = neighbour_adjazenzmatrix (a, i)) != -1)
            printf ("%i, ", x);
        printf ("n");
    }

    int c [N];

    bfs (a, c, 0);

    for (i = 0;  i < N;  i++)
        printf ("%c, ", c [i] + 'a');

return 0;
}

Ich mache kurz Pause, nachher lerne ich weiter.

Ach, ja, ich kann das Programm verändern, es macht ja eine TeX Ausgabe, dann kann ich den Graphen anschaulich darstellen, die gefundene Komponente

Und der Witz ist ja, ich könnte die im Diagramm dick machen, das mache ich aber nicht - sondern ich gebe einen extra Graphen aus.

Das sieht doch nett aus.

Das auch

Hier kann man aber sehen, in dem Algorithmus ist ein Fehler, zumindest in dem rekursiven, weil es die Kante nicht gibt. Irgendwo ist ein Fehler. Im ersten Graphen ist jedenfalls keine Kante da, im zweiten schon

Nein, das stimmt nicht, das ist kein Fehler! Stop, das sieht nach einem Fehler aus, aber es ist keiner! Es ist kein Fehler, auch, wenn es nach einem aussieht!

Denken sie nach, was die Komponente liefert. Denken sie nach, wie man einen Graphen darstellt

Denken sie nach - dass man einen Graphen mit mehreren ausgehenden Kanten durch einfügen von Zuständen, zu einem Graphen machen kann, mit zwei Folgeknoten

Warum, wie stellen wir Automaten dar

a1 []
a2 []

Der Witz bei der Komponente ist ja - so wie ich die ausgegeben habe, es gibt eine Besserungsmöglichkeit -

meine Komponente, überlegen sie, es geht von

a, b, c, d,

aber e, folgt auf a

dann geht sie trotzdem

a, b, c, d, e

Weil, wir sehen nicht, dass e hier auf a folgt

Das ist der Witz wir bräuchten ein zwei dimensionales array

1. >a
   

   1. >b c d
      

   2. >e
      

Und jetzt der Witz, der Verbesserungsvorschlag, ich habe es vorher mit der Ausgabe probiert, ich habe probiert einen Zeilenvorschub zu leisten,

das beste wäre, die Komponente, als den entstandenen Pfad, oder viel mehr Baum, wieder in einer Adjanzenzmatrix dar zu stellen und dann muss es gehen.

Ich habe schon die bessere Lösung

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>

#define N       7


int Q [1024];
int Qtop = 0;
int Qbottom = 0;

void Qput (int v) {
    Q [Qtop] = v;
    Qtop ++;
}

int Qget (void) {
    int v = Q [Qbottom];
    Qbottom++;
return v;
}

int QIsNotEmpty () {
    return (Qbottom < Qtop);
}

int neighbours_index [N];

void init_neighbours_index () {
    int i;

    for (i = 0;  i < N;  i++)
        neighbours_index [i] = 0;
return;
}

void reset_neighbours_index (int i) {
    neighbours_index [i] = 0;
}

int neighbours_adjazenzmatrix (int a [N][N], int b [N], int v) {
    int i, j;

    for (i = 0, j = 0;  i < N;  i++) {
        if (a [v][i] != -1) {
            b [j] = a [v][i];
            j++;
        }
    }
return j;
}

int neighbour_adjazenzmatrix (int a [N][N], int v) {
    int t;

    while (neighbours_index [v] < N) {
        if (a [v][neighbours_index [v]] != 0) {
            t = neighbours_index [v];
            neighbours_index [v]++;
            return t;
        }
        neighbours_index [v]++;
    }
return -1;
}

int visited [N];

void init_visited (void) {
    int i;
    for (i = 0;  i < N;  i++)
        visited [i] = 0;
return;
}

int notAllVisited () {
    int i;

    for (i = 0;  i < N;  i++)
        if (visited [i] == 0)
            return 1;
return 0;
}

int _bfs (int a [N][N], int b [N][N], int v) {
    int w;

    if (notAllVisited ()) {
        while ((w = neighbour_adjazenzmatrix (a, v)) != -1) {
            if (visited [w] == 0) {
                visited [w] = 1;
                b [v][w] = 1;
                _bfs (a, b, w);
            }
        }
    }
}

int bfs (int a [N][N], int b [N][N], int v) {
    int i, j;

    for (i = 0;  i < N;  i++)
        for (j = 0;  j < N;  j++)
            b [i][j] = 0;
    init_neighbours_index ();
    init_visited ();
    visited [v] = 1;
    _bfs (a, b, v);
    printf ("n");
}


void generate_adjanzenzmatrix (int a [N][N], int n) {
    int i, j;

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++) {
            a [i][j] = -1;
        }
    }


    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++) {
            if ((a [i][j] == -1) \&amp;\&amp; (a [j][i] == -1)) {
                a[j][i] = a [i][j] = rand () % 2;
            }
            if (i == j)
                a [i][j] = a [j][i] = 1;

        }
    }
}

void print_csv_adjanzenzmatrix (int a [N][N], int n) {
    int i, j;

    printf ("%c,", ' ');
    for (i = 0;  i < n-1;  i++)
        printf ("%c,", i + 'a');
    printf ("%cn", i+'a');
    for (i = 0;  i < n;  i++) {
        printf ("%c,", i+'a');
        for (j = 0;  j < n-1;  j++) {
            printf ("%c,", a [i][j] + '0');
        }
        printf ("%cn", a [i][j] + '0');
    }
}

void read_csv_adjanzenzmatrix (int a [N][N], int n) {
    int i, j;
    int ch;

    scanf ("%c,", \&amp;ch);
    for (i = 0;  i < n-1;  i++)  {
        scanf ("%c,", \&amp;ch);
    }
    scanf ("%cn", \&amp;ch);


    for (i = 0;  i < n;  i++) {
        scanf ("%c,", \&amp;ch);
        for (j = 0;  j < n-1; j++) {
            scanf ("%i,", \&amp;ch);
            a [i] [j] = ch;
        }
        scanf ("%in", \&amp;ch);
        a [i] [j] = ch;
    }

}

void convert_csv_adjanzenzmatrix_to_adjazensliste (int a [N][N], int b [N][N], int n) {
    int i, j, k;

    for (i = 0;  i < n;  i++) {
        for (j = 0, k = 0;  j < n;  j++) {
            if (a [i][j] == 1) {
                b [i][k] = j;
                k++;
            }
        }
        for (; k < n;  k++)
            b [i][k] = -1;
    }

}

void convert_csv_adjanzenzliste_to_adjazensmatrix (int a [N][N], int b [N][N], int n) {
    int i, j;

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++)
            a [i][j] = 0;
    }

    for (i = 0;  i < n;  i++) {
        for (j = 0;  j < n;  j++)
            if (b [i][j] != -1)
                a [i][b[i][j]] = 1;
    }

}

void read_csv_adjanzenzliste (int b [N][N], int n) {
    int i, j, k;
    int ch = 0;

    scanf ("%c,", \&amp;ch);
    for (i = 0;  i < n-1;  i++)  {
        scanf ("%c,", \&amp;ch);
    }
    scanf ("%cn", \&amp;ch);

    for (i = 0;  i < n;  i++) {
        scanf ("%c,", \&amp;ch);
        for (j = 0, k = 0;  j < n-1;  j++) {
            scanf ("%c,", \&amp;ch);
            if (ch == ' ')
                b [i][j] = -1;
            else
                b [i][j] = ch - 'a';

        }
        scanf ("%cn", \&amp;ch);
        if (ch == ' ')
            b [i][j] = -1;
        else
            b [i][j] = ch - 'a';
    }
}

void print_csv_adjanzenzliste (int b [N][N], int n) {
    int i, j;
    printf ("%c,", ' ');
    for (i = 0;  i < n-1;  i++)
        printf ("%c,", i + 'a');
    printf ("%cn", i+'a');
    for (i = 0;  i < n;  i++) {
        printf ("%c,", i+'a');
        for (j = 0;  j < n-1;  j++) {
            if (b [i][j] != -1)
                printf ("%c,", b [i][j] + 'a');
            else
                printf (" ,");
        }
        if (b [i][j] != -1)
            printf ("%cn", b [i][j] + 'a');
        else
            printf (" n");
    }

}



void print_tex (int a [N][N]) {
    int i, j;
    int codez = 8;
    printf("\documentclass{article}n");
    printf("\usepackage[utf8]{inputenc}n");
    printf("\usepackage{pgf, tikz}n");
    printf("\usetikzlibrary{arrows , automata , positioning}n");
    printf("\begin{document}nn");


    printf("\begin{center}n");
    printf("\begin{tikzpicture}[>=stealth',shorten >=1pt,auto,node distance=2.5cm]n");
    printf("%Knotenn");

    printf("\node (a) [state, thick] {a};n");
    printf("\node (b) [state, thick, right of= a, below of=a] {b};n");
    printf("\node (c) [state, thick, left of= a, below of=a] {c};n");
    printf("\node (d) [state, thick, below of=b, right of=b] {d};nn");
    printf("\node (e) [state, thick, below of=c, left of=c] {e};nn");

    printf("\node (g) [state, thick, below of=d, left of=d] {g};nn");
    printf("\node (f) [state, thick, below of=e, right of=e] {f};nn");

    printf("%Verbindungenn");
    printf("\path[thick,->]n");



    char *leftright [] = {"left", "right"};
    char *abovebelow [] = {"above", "below"};

    for (i = 0;  i < N;  i++) {
        for (j = 0;  j < N; j++) {
            if (a [i] [j] == 1)
                printf ("(%c) edge [bend angle=20, bend left,below] (%c)n", (char)('a' + i), (char)('a' + j));
        }
    }
    printf(";n");
    printf("\end{tikzpicture}n");
    printf("\end{center}n");

}


void print_tex_component (int b [N][N]) {
    int i, j;
    int codez = 8;


    printf("\begin{center}n");
    printf("\begin{tikzpicture}[>=stealth',shorten >=1pt,auto,node distance=2.5cm]n");
    printf("%Knotenn");

    printf("\node (a) [state, thick] {a};n");
    printf("\node (b) [state, thick, right of= a, below of=a] {b};n");
    printf("\node (c) [state, thick, left of= a, below of=a] {c};n");
    printf("\node (d) [state, thick, below of=b, right of=b] {d};nn");
    printf("\node (e) [state, thick, below of=c, left of=c] {e};nn");

    printf("\node (g) [state, thick, below of=d, left of=d] {g};nn");
    printf("\node (f) [state, thick, below of=e, right of=e] {f};nn");

    printf("%Verbindungenn");
    printf("\path[thick,->]n");



    char *leftright [] = {"left", "right"};
    char *abovebelow [] = {"above", "below"};

    for (i = 0;  i < N;  i++) {
        for (j = 0;  j < N; j++) {
            if (b [i] [j] == 1)
                printf ("(%c) edge [bend angle=20, bend left,below] (%c)n", (char)('a' + i), (char)('a' + j));
        }
    }
    printf(";n");
    printf("\end{tikzpicture}n");
    printf("\end{center}n");
    printf("\end{document}n");

}




int main (int argc, char *argv []) {
    time_t t;
    int n = N;
    int a [N][N];
    int b [N][N];
    int component [1024];



    srand ((unsigned) time (\&amp;t));

    if (argc != 3) {
        printf ("Wrong Parameter!ng: generete generate_adjanzenzmatrixnr: read_csv_adjanzenzmatrixns: read_csv_adjanzenzlistennp: print_csv_adjanzenzmatrixnq: print_csv_adjanzenzliste");
        return 1;
    }
    if (strcmp(argv [1], "r") == 0) {
        read_csv_adjanzenzmatrix (a, n);
        convert_csv_adjanzenzmatrix_to_adjazensliste (a, b, n);
    }
    else if (strcmp (argv [1], "g") == 0) {
        generate_adjanzenzmatrix (a, n);
        convert_csv_adjanzenzmatrix_to_adjazensliste (a, b, n);
    }
    else if (strcmp (argv [1], "s") == 0) {
        read_csv_adjanzenzliste (b, n);
        convert_csv_adjanzenzliste_to_adjazensmatrix (a, b, n);
    }
    else
        printf ("Wrong Parameter!ng: generete generate_adjanzenzmatrixnr: read_csv_adjanzenzmatrixns: read_csv_adjanzenzlistennp: print_csv_adjanzenzmatrixnq: print_csv_adjanzenzliste");


    if (strcmp (argv [2], "p") == 0)
        print_csv_adjanzenzmatrix (a, n);
    else if (strcmp (argv [2], "q") == 0)
        print_csv_adjanzenzliste (b, n);
    else if (strcmp (argv [2], "t") == 0) {
        int c [N][N];

        bfs (a, c, 0);
        print_tex (a);
        print_tex_component (c);
    }





return 0;
}

https://drive.google.com/file/d/1ws9Vq7kBqBDmRy1mKSDRVsoTjvULOduR/view?usp=drive_link">

Ich werde mir das Buch Bitcoins from Scratch stück für stück erarbeiten. Mit dem jetzt gelungenen BFS oder DFS wie man es auch sieht, zur Bestimmung von Komponenten in graphen möglichst kurz und ich sage gleich. Zum Beispiel ist Robert Sedgwick gut. Aber ich finde ohne zu viel mathematische Definitionen geht es nicht. Es geht nicht ohne das, was Pfad und Komponente wirklich ist.

Möglich ist damit schon etwas für einen aha effekt. Mit der richtigen programmierumgebung lassen sich beim Smartphone einfach GPS Standort Daten auslesen. In der küche ein Stuhl,der Tisch, die Katze. Wie geht es am effektivsten

Oder Flughafen lassen sich ein speichern.

Die länge spielt im Graphen keine Rolle? Falsch. Zwar sind Graphen mit Tisch,Stuhl ohne numerik möglich. Doch gewichtete Graphen lassen numerische werte an Kanten zu. Obwohl ich die Knoten in der Graphik platzieren kann, wie ich will, kann ich Gewichte abstände, der Flughäfen an die Kante tun und so den effektivsten weg berechnen

Auch meine Automaten werden bessere Aufgaben erzeugen.in Zukunft kann ich zum Automaten Test vorgeben, wie.

Wie das geht, das ist ganz einfach, das mache ich morgen. Wir können gleich mathematisch damit anfangen - ich sage mathematisch. Wir erzeugen einen Wald - jetzt kommt der berühmte Wald. Danach gehen wir alle Kanten durch von jedem Baum im Wald. Und addieren die Gewichte der Kanten.

Die

Es ist sicher so, dass der Stern von Israel etwas in die hose ging. vieles an der ganzen Sache ist nicht lupenrein. Das ist richtig, der Stern ist scheisse und die Idee Kacke. Auf der anderen Seite, woher wüsste man, wie man es richtig macht, wie man es falsch macht

Ich verstehe absolut, dass das alles reiner Unsinn ist. Was da betrieben wird. Ich verbitte mir allerdings eines

Ich selber war am Ende auf dem technischen Gymnasium und zu vor auf dem altsprachlichen. Meine Mutter war Lehrerin auf dem Altsprachlichen. Und ich selber hatte bis zur 9. Latein. Die Geschichte von Troja kannte ich früh

Ich möchte mal anmerken, dass es keine Frage des Rassismus ist, zu behaupten, ich würde einen Judengott glauben - und keinen der Griechen. Ich glaube an Venus und Co.

Sehr stark sogar. Und das ist keine Rassistische Frage. dieses Denken auf das Problem Israel zu übertragen, Venus und Co, das sind Götter und der Kampf unter Menschen ist relativ amüsant. Wir sind nur Sterbliche

Und die Götter sind Wahrzeichen, ich muss mich nicht in den Fehden verstricken und in irgendwelchen alltäglichen Müssiggängen, um mich an dem schönen zu orientieren

und dafür stehen diese Götter, Schönheit

Ich selber halte nichts von Israel und besonders nicht von dem Gott da. Ich möchte aber rassistische Vergleiche mir erspart wissen

Und ebenso wenig wie ich etwas von dem jüdischen Gott halte, halte ich etwas von dem gleichen christlichen. Das ist alles barer Unsinn

Und wer was falsch gemacht hat, sieht man gleich, an dem nicht so überzeugenden Stern.

Der Stern von Israel ist allerdings reiner Unsinn, weil er nicht zusammenhängend ist. In der Graphentheorie gibt es auch solche Graphen, man nennt sie nicht zusammen hängende Graphen

wenn ich zum Beispiel - a, b, c und d habe, und a, b, c sind miteinander verbunden, aber d nicht. Dann gehört d zwar zum Graphen - gehört trotzdem dazu, aber der Graph ist nicht zusammenhängend. Warum ich mir allerdings als Staatswappen einen Graphen aussuchen muss, der unzusammenhängend ist weiss ich nicht.

Man könnte daraus ableiten, dass lauter Punkte in der Fahne, das allerbeste sind. Eine weisse Fahne mit lauter Rosa Punkten

Doch das sind auch Graphen, halt Graphen die nicht zusammenhängen. Auch lauter Punkte sind das. Das ist, weil es in der Mathematik, die Leere Menge, ebenso zur Menge gehört

Lauter Rosa Punkte - das ist eine Menge

V = {1,2,3, ..., n}
[7code]
Und eine Menge
[code]
E = {}

Das ist trotzdem ein Graph, auch, wenn E leer ist.

Das meine ich ernst und hat mit dem Israelischen Symbol nichts zu tun.

Was die Rassistischen Beleidigungen - betrifft, nämlich von Männern, die als Frauen auftreten in einem Kontest und dabei Frauen darstellen

Dazu möchte ich folgendes sagen: Dass sie Israel beschissen finden und nichts anderes. Das verstehe ich. weil das reiner Unsinn ist.

Wenn sie allerdings meinen, der Kampf der Götter, Venus und Co, hängt davon ab, was sie rassistisch zu kämpfen haben, als normal sterbliche, dann irren sie sich gewaltig

Ich war zunächst auf dem Altsprachlichen und sie brauchen nicht versuchen mich damit zu vergleichen

Also, erstens

Das ist auch ein Graph

V = {1,2,3, ..., n}

Und eine Menge

E = {}

Obwohl nicht zusammenhängend. Hier hängt gar kein Punkt zusammen

Jetzt gibt es

1.) David 2.) Davina

Die Flagge - des Davids - als Davidstern - ist blau und ein unzusammenhängender Graph, bei dem jeweils zwei Graphen

>K_3

existieren

K ist der vollständige Graph

Und

>K_3

ist der, bei dem

E := {{1,2},{1,3},{2,3}}

Bei

V := {1,2,3}


Und davon gibt es halt zwei. Beim Davidstern

Und die Dawina, die hat eine andere Fahne

Das sind lauter Rosa Punkte auf Weiss

1.) Erstens nicht blau, sondern Rosa
2.) sind das Lauter Punkte, die nicht verbunden sind

das stimmt nicht, dass das widerum kein Graph ist. Hier ist keiner miteinander Nachbarn. Das sagt, man Nachbarn, bei Knoten

Das ist Trotzdem ein Graph, lauter

K_1

Graphen, Rosa nebeneinander.

Also, erstens

Das ist auch ein Graph

V = {1,2,3, ..., n}
Und eine Menge
E = {}

Obwohl nicht zusammenh"angend. Hier h"angt gar kein Punkt zusammen

Jetzt gibt es

1.) David
2.) Davina

Die Flagge - des Davids - als Davidstern - ist blau und ein unzusammenh"angender Graph, bei dem jeweils zwei Graphen

K_3 existieren

K ist der vollst"andige Graph

Und K_3 ist der, bei dem

E := {{1,2},{1,3},{2,3}}

Bei

V := {1,2,3}


Und davon gibt es halt zwei. Beim Davidstern

Und die Dawina, die hat eine andere Fahne

Das sind lauter Rosa Punkte auf Weiss

1.) Erstens nicht blau, sondern Rosa
2.) sind das Lauter Punkte, die nicht verbunden sind

das stimmt nicht, dass das widerum kein Graph ist. Hier ist keiner miteinander Nachbarn. Das sagt, man Nachbarn, bei Knoten

Das ist Trotzdem ein Graph, lauter

K_1

Graphen, Rosa nebeneinander.

Dein Nationalismus hat mit Mathematik nichts zu tun - nat"urlich ist das Symbol von Israel mal komplett daneben

Ich will das nicht rechtfertigen - mathematisch ist es so, dass sie zwei Graphen K_3 haben, das sind trotzdem Graphen, auch, wenn nicht zusammenh"angen. Mathematisch. Zwei Komponenten

Ich will das trotzdem nicht rechtfertigen. Das ist scheisse. Der Nationalismus allerdings, ich w"urde so etwas glauben oder - ich w"urde das nicht scheisse

Und die Rosa Punkte Tapete, das sind "ubrigens Graphen, sei deswegen scheisse - das stimmt nicht

Und Mathematik ist nicht zur Verteidigung des Nationalismus da.


Doch, das das stimmt, sie brauchen keinen zusammenh"angenden Graphen, der Stern ist verfehlt, als Staatswappen

Mathematisch nicht falsch - sage ich mathematisch

1.) Sie k"onnnen "ubrigens beim Pentagramm, die Punkte an anderer Stelle hin machen, also Mathematisch

2.) Sie haben zum Beispiel deswegen unzusammenh"angende Graphen. Angenommen

K_3, 2 x


Erstens - die heissen, 1, 2, 3, 4, 5, 6

Und nicht 1, 2, 3

Und das zwei Mal. Das macht zum beispiel beim "offentliche Verkehr einen Sinn

Angenommen sie haben die Verbindungen -


V = {Stuttgart, Esslingen, Reutlingen, New York, Washington DC, San Francisco}


so, das ist V

Wenn sie jetzt Zugverbindungen suchen

dann gibt es eine Zugverbindung


E := {{Stuttgart, Esslingen},{Stuttgart, Reutlingen},{Esslingen, Reutingen},{New York, Washington DC},{New York, San Francisco},{Washington DC, San Francisco}}


Das heisst nicht, dass sie nicht von Stuttgart nach New York kommen. Nur nicht mit dem Zug. Dann m"ussen sie das Flugzeug dazwischen nehmen

Und - das kennen sie auch in Deutschland. Es gibt so strecken mit der Bahn, da m"usssen zwischen drin laufen. Die Eine Bahnverbindung, die andere. Und dazwischen m"ussen sie laufen oder das Auto nehmen, in dem falle das Flugzeug.

Bezogen auf den Zug stimmt das.

es ist mathematisch nicht falsch, ich w"urde es nicht als Wappen nehmen


Verstehen sie Graphentechnisch, ist die Argumentation mit Stuttgart, Berlin und M"unchen, vollkommen richtig und New York, Washington DC - San Francisco, wobei das eine Route ist

Die andere Sache ist - dass sie ja in Teilgraphen rechnen - das soll das Ding nicht rechtfertigen. Ich verstehe nicht, warum man sich das als Symbol aussucht

Zur"uck zur Mathematik. Ich mache jetzt Mathe und nicht staatssymbol

Sie haben eine Menge


V = {1,2,3,4,5,6}


Und sie k"onnen eine Untermenge


V'={1,2,3}


ebenso k"onenns ie haben


E = {{1,2},{1,3},{1,4},...}


Und von dem E k"onnen sie eine Untermenge E' haben

sie k"onnten aus dem Stern einen Benzolring machen, in der Chemie Benzolring, in der Mathematik Ring


E = {{1,2},{2,3},...}


Und dann immer noch die zwei Graphen verbinden. Wie jetzt. Die zwei K_3 Komponenten Das ist ein K_6 Graph - und der besteht aus zwei zusammenh"angenden Komponenten K_3

Und totzdem k"onnen sie - den Ring machen drum und k"onnen dann sagen, der Stern ist eine Untermenge

E'

auf der anderen Seite, das ist mathematisch richtig. Sie machen keine Konstrukte zum Zeichnen. Das ist nicht zum Zeichnen. Das sind Mengen. Mengen haben untermengen

Warum das ein Staatssymbol ist, weiss ich nicht