Wth? übernimmt nichtübergebenen Wert (Graph)

[Mujahiddin]

Hallo...
Ich habe einen Graphen, der mehrere Knoten, sogenannte Zentralen, beinhaltet. Jeder Knoten verweist auf ein Kanten-Array. Jede Kante hat zwei Knoten, "start" und "end". Wenn ich mit einem Knoten eine Kante nehme und deren Ende bestimmen will, muss man dies über die Methode

1
2
3
4
5
6
public Knoten getEnd(Knoten start)
{
    if (start == this.start)
        return end;
    return start;
}

aus der Klasse Kante bewerkstelligen.
Als Beispiel mal die Methode isNeighbourOf(Knoten neighbour) aus der Klasse Knoten:

1
2
3
4
5
6
7
public boolean isNeighbourOf(Knoten neighbour)
{
    for(int i=0; i<links.length; i++)
        if(links[i].getEnd(this) == neighbour)
            return true;
    return false;
}

(links = Kanten-Array)

Wenn man nun einen 'random' Pfad von einem zu einem anderen bestimmten Knoten definieren möchte, ackert er sich von einem Nachbarknoten zum nächsten Nachbarknoten, bis er eben zum Ziel ankommt und man kriegt die Knoten, die passiert wurden, zurück... Als 'Feature' ist eingebaut, dass man einen Knoten niemals zweimal passieren kann, das heißt, er checkt den ersten Nachbarn und guckt in einer vorgegebenen Liste, ob dieser Nachbar schon mal passiert wurde, wenn nein, dann gibt er ihm den Befehl weiter, wenn ja, selber Vorgang mit zweitem Nachbarn usw. usf.

Nun zum Problem: Ich habe eine GraphDemo erstellt und wollte schauen, ob so weit alles funzt, zu meiner Überraschung hat sich herausgestellt, dass es dies nicht tut...
Und zwar habe ich verschiedene Zentralen erstellt, die danach miteinander verknüpft, und die Methode 'getRandomPath' von irgendeinem Knoten zu einem anderen aufgegeben.

Start und Ende hat er gut ermittelt, als er dann bei Start losging, hat sein erster Nachfolger (über links[i].getEnd(this)) den Befehl erhalten, weiterzumachen. Beim zweiten Knoten ereignet sich allerdings ein unerklärliches Phänomen: über den Befehl getEnd(this) wird scheinbar er selbst zurückgegeben. Beim Debuggen ist aber alles perfekt! Er markiert die Stelle 'return start (start = Nachbar von Knoten 2);' und gibt somit den eigentlichen Nachbarn zurück, wenn er wieder zum Knoten springt, wird das zurückgegebene als er selbst erkannt und es würde in einer Endlosschleife ausarten, wäre mein 'Feature' mit Einmalpassieren nicht da...

Also Fazit:
Knoten 1 > läuft alles prima, er geht zu Knoten 2.
Knoten 2 > läuft nicht prima, er geht zu sich selbst.
> Da Knoten 2 bei getEnd(this) scheinbar sich selber zurückgibt, obwohl er das eigentlich nicht tut, aber irgendwie auch doch, wird eine Endlosschleife verhindert, weil ja das vermeintliche Ende von Knoten 2 (Knoten 2 selbst) bereits passiert wurde.
> Vollkommener Schwachsinn oder hab ich nen fatalen Fehler?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
for(int i=0; i<links.length; i++)
    {
        boolean isPassed = false;
        for(int j=0; j<passed.length; j++)
            if(links[i].getEnd(this) == passed[j])
            {
                isPassed = true;
            }
        if(!isPassed)
        {
            Knoten[] passedPlusThis = new Knoten[passed.length+1];
            for(int k=0; k<passed.length; k++)
                passedPlusThis[k] = passed[k];
            passedPlusThis[passed.length] = this;
            Knoten neighbour = links[i].getEnd(this);
            Knoten[] path = neighbour.getRandomPath(end, passedPlusThis);
            if(path != null)
                return path;
        }
    }

Danke im Voraus, sorry für das viele Geschreibe, will nicht, dass nachher noch Fragen auftauchen

[Marco13]

Ja, das Problem bei solchen Fragen ist, dass man als Außenstehender noch weniger weiß, wo der Fehler liegen könnte - und dass es, wenn man es jetzt testweise mal selbst hinschreiben würde, funktionieren würde

Was sagt er denn so bei

1
2
3
4
5
6
7
8
9
10
11
12
public Knoten getEnd(Knoten start)
{
    System.out.println("Auf Kante "+this+" mit "+this.start+" und "+this.end);
    System.out.println("gib mir die Gegenseite zu "+start);
    if (start == this.start)
    {
        System.out.println("Das ist "+end+". Ist das der übergebene? "+(end==start));
        return end;
    }
    System.out.println("Das ist "+this.start+". Ist das der übergebene? "+(this.start==start));
    return start;
}

Sicher, dass dort mit == verglichen werden muss, und nicht mit .equals(...) ?

[Mujahiddin]

LOOOOOOOOOOOL
xDD
sooo dumm...
ich bin wirklich dumm... tut mir leid... tut mir echt sehr leid... es muss return this.start heißen, und nicht start...

So ein dummer Leichtsinnsfehler... Und ich habe schon an meiner Intelligenz gezweifelt (jetzt weiß ich wenigstens, dass ich kaum welche besitze)

so kommt man durcheinander, wenn man dauernd selbe variablen in methoden wie in attributen verwendet <.<

danke trotzdem marco für die bemühung :p das problem lag nicht an ==, schließlich ging ja beim debuggen alles... aber er hat start von der methode und nicht start des objekts zurückgegeben...

mit freundlichen grüßen

[Marco13]

Jaja, dumm bin ich ja dann auch - hab's ja auch nicht gesehen

[Schumi]

Ja, da ist dann die Frage, ob es so sinnvoll ist einen Parameternamen gleich einem Variablennamen zu wählen wenn man ihn nicht direkt diesem zuweisen will (ala Setter).