# Pssende Datenstruktur für ein Netz



## System.exit(0) (30. Aug 2015)

Hallo zusammen,

ich überlege schon seit ein paar Tagen, wie ich datentechnisch Folgendes abbilde:

Ich habe ein Netz von Knoten, die Energie weiter leiten sollen.
Der Spieler soll die Knotenpunkte frei setzen können.
Bis zu einem gewissen Abstand verbinden sich die Knoten automatisch.
Die Knoten verteilen die ankommende Energie im Urzeigersinn an die nächsten Knotenppunkte, die innerhalb des oben erwähnten Abstands liegen.
Der Spieler soll aber auch festlegen können, dass Energie nur in eine Richtung zwischen zwei Knoten fließen kann.

Wie bilde ich das möglichst geschickt ab? Mir geht es hier nur um die Sturktur für das Netz. Der Rest der Implementierung folgt noch, dürfte aber nicht übermäßig schwierig sein.

Ich hatte an eine

```
ArrayList <Knoten> nachbarKnoten;
```
gedacht, die alle Knoten der Reihe nach auflistet (im Uhrzeigersinn).
Für die Implementierung der "nur eine Richtung" nehme ich noch eine weitere

```
ArrayList <boolean> energieTransportieren;
```
welche dann parralel zur ArrayList nachbarknoten loggt, ob Energie transportiert werden kann oder nicht.

Die Klasse Knoten enthält auch noch eine

```
Single ID;
```
die das Suchen nach Knoten für das Entfernen oder umstellen der Richtung erleichtern soll.

Was haltet Ihr davon?

mfg

System.exit(0)


----------



## Saheeda (31. Aug 2015)

Das auf mehrere Listen zu verteilen ist meines Erachtens riskant. Du musst tierisch aufpassen, dass dir nichts durcheinander gerät. Es wäre sinnvoller, alle Informationen, die irgendwie zusammengehören, auch zusammen zu speichern.

Ich würde eine Map nehmen (z.B. mit der ID o.Ä. als Schlüssel) und Nachbarknoten bzw. den Weg dahin als Attribute im Knoten speichern, z.B.:


```
class Knoten{

        Set<Knoten> nachbarn;
           
        boolean wegZuMirBegehbar;
       
        boolean wegVonMirBegehbar;

}
```


----------



## System.exit(0) (31. Aug 2015)

Würde die Deklaration oben bedeuten, dass zu jedem Knoten im Set je zwei boolean existieren?
So habe ich die Implementierung eines Maps nämlich nicht verstanden.
Kannst du das genauer angeben?


----------



## Saheeda (31. Aug 2015)

@System.exit(0) 
Wenn ich dein "Zwei-Wege-System" richtig verstanden habe, dann müsste man denke ich beides angeben, ja: Ob ein Knoten Energie empfangen und ob ein Knoten Energie senden kann.


Bei einem anderen Projekt hatte ich eine ebenfalls netzartige Struktur so implementiert, vielleicht trifft das deinen Anwendungsfall genauer. Bei mir gab es aber keine Unterscheidung der Richtung - ist eine Kante aktiviert, darf sie in jede Richtung abgelaufen werden:


```
class Kante{
    boolean aktiviert;
    Knoten start;
    Knoten ende;
}

class Knoten{
    boolean aktiviert;   
}
```


----------



## CSHW89 (2. Sep 2015)

Ist das nicht ein gerichteter Graph (https://de.wikipedia.org/wiki/Graph_(Graphentheorie))? Um Graphen zu speichern gibt es einige vorgefertigte Pakete.

lg Kevin


----------



## System.exit(0) (4. Sep 2015)

Danke für die Antworten.
Das Beispiel von Saheeda sieht mir auch nach einem Graphen aus. 

Ich benötige aber ein Netz, in dem es ejde Mengen n:m Beziehungen gibt.

Beispiel: 
Knoten 1 hat die Nachbarknoten K2 - K6 (also fünf).
K2 wiederum hat aber nur K1 als Nachbar, weil er sagen wir links alleine steht.
K3 hat K1, k4, K5 und noch die weiteren Knoten K7 und K8 als Nachbarn.
usw.

Somit benütige ich für jeden Knoten eine Liste der Nachbarknoten:
K1_Nachbarn = (K2, K3, K4, K5, K6)
K2_Nachbarn = (K1)
K3_Nachbarn = (K1, K4, K5, K7, K8)
usw.
Gleichzeitig benötige ich für jeden Nachbarknoten ein Kennung, ob Energie an diesen abgegeben werden kann.
Hierbei benötige ich nur EINE Richtung, da ich immer vom jeweiligen Knoten ausgehe.

Wenn ich jetzt noch eine boolean für "erhält Energie" ansetze, müsste das Set so aussehen:
Dabei würde z. B. K1 keine Energie an K4 schicken, K4 aber an K1)
K2 würde keine Energie an K1 schicken, K1 aber an K2.
K5 würde nur Energie für K3 sammeln, aber weder von K1 noch K3 Energie erhalten.
usw.

K1_Nachbarn = ((K2, true), (K3, true), (K4, false), (K5, false), (K6, true))
K2_Nachbarn = ((K1, false))
K3_Nachbarn = ((K1, true), (K4, true), (K5, false), (K7, false), (K8, false))

Ich denke, dass eine Map-Lösung eher nicht funktioniert, da ja jeder Map auf die gleiche Instanz des Knotens zurück greift. 

oder?


----------

