Esempio n. 1
0
  public static void main(String args[]) {
    Graph gr = new Graph();
    // Graph: 8 Knoten
    Knoten a, b, c, d, e, f, g, h;

    a = new Knoten("A");
    b = new Knoten("B");
    c = new Knoten("C");
    d = new Knoten("D");
    e = new Knoten("E");
    f = new Knoten("F");
    g = new Knoten("G");
    h = new Knoten("H");

    gr.fuegeEin(a);
    gr.fuegeEin(b);
    gr.fuegeEin(c);
    gr.fuegeEin(d);
    gr.fuegeEin(e);
    gr.fuegeEin(f);
    gr.fuegeEin(g);
    gr.fuegeEin(h);

    a.fuegeEin(new Kante(b, "1"));
    a.fuegeEin(new Kante(g, "5"));
    b.fuegeEin(new Kante(c, "7"));
    c.fuegeEin(new Kante(a, "6"));
    c.fuegeEin(new Kante(f, "2"));
    d.fuegeEin(new Kante(e, "2"));
    d.fuegeEin(new Kante(h, "12"));
    e.fuegeEin(new Kante(a, "9"));
    e.fuegeEin(new Kante(h, "13"));
    f.fuegeEin(new Kante(e, "3"));
    f.fuegeEin(new Kante(d, "5"));
    g.fuegeEin(new Kante(c, "3"));

    gr.gibAus();
    System.out.println(gr.gleicheKanten());
    System.out.println(gr.sucheWeg(f, b));
    System.out.println(gr.istZyklenfrei());
  }
Esempio n. 2
0
  public void Berechne_Weg(int Start_ID, int Ziel_ID) {
    SK =
        Gesamtliste.get(
            GetIndexOfElement(
                Gesamtliste,
                Start_ID)); // Startknoten aus Gesamtliste holen; // hier später: Datenbankabfrage,
                            // Erstellung einer neuen Instanz vom Knoten
    SK.G = 0;
    SK.F = 0;
    ZK =
        Gesamtliste.get(
            GetIndexOfElement(
                Gesamtliste,
                Ziel_ID)); // Zielknoten aus Liste holen; // hier später: Datenbankabfrage,
                           // Erstellung einer neuen Instanz vom Knoten

    open_L.add(SK);

    while ((!closed_L.contains(ZK))
        && (!open_L
            .isEmpty()) /* Zielknoten nicht in geschlossener Liste && Liste_offen = empty*/) {
      akt_K = open_L.pollFirst(); // aktueller Knoten = Knoten mit niedrigstem f-Wert
      closed_L.add(akt_K); // aktueller Knoten in geschlossene Liste hinzugefügt

      for (int i = 0; i <= akt_K.AngrKn_ID.length - 1; i++) { // Für alle angrenzenden Knoten tue:

        angr_K =
            Gesamtliste.get(
                GetIndexOfElement(
                    Gesamtliste,
                    akt_K
                        .AngrKn_ID[
                        i])); // hier später: Datenbankabfrage, Erstellung einer neuen Instanz vom
                              // Knoten

        if (closed_L.contains(angr_K)) {
          /*nichts*/
        } // wenn schon in geschlossener Liste, dann zue nichts
        else { // ansonsten (wenn nicht in geschlossener Liste)
          if (open_L.contains(angr_K)) { // wenn schon in offener Liste

            if (G_berechnen(akt_K.x, akt_K.y, akt_K.z, angr_K.x, angr_K.y, angr_K.z)
                < G_berechnen(
                    angr_K.Vorg.x, angr_K.Vorg.y, angr_K.Vorg.z, angr_K.x, angr_K.y, angr_K.z)) {
                /* if(g von aktuellen Knoten zu angrenzen Knoten < angrenzenden zu engrenzenden.vorgänger */
              angr_K.Vorg = akt_K;
            }
          } else { // wenn noch nicht in offener Liste

            angr_K.Vorg = akt_K; // aktuellen Knoten als Vorgänger von angrenzenden Knoten eintragen
            angr_K.G =
                angr_K.Vorg.G
                    + G_berechnen(
                        angr_K.x, angr_K.y, angr_K.z, angr_K.Vorg.x, angr_K.Vorg.y, angr_K.Vorg.z);
            angr_K.F =
                (int) ((int) angr_K.G + (int) H_berechnen(angr_K.x, angr_K.y, angr_K.z) * h_faktor);
            open_L.add(angr_K); // zu offener Liste hinzufügen
          }
        }
      }
    }
    //	    // speichert IDs in Array
    //	    if(!open_L.isEmpty()){									// Wenn Zielknoten gefunden
    //		    Knoten Knoten1 = ZK;
    //		    int IDcount=-1;
    //		    while(IDcount!=SK.ID){								// "Gehe Weg Rückwärts" und speicher die zu begehenden
    // Knoten
    //		    	IDcount = Knoten1.ID;
    //		    	this.Route.add(0, IDcount);
    //		    	Knoten1 = Knoten1.Vorg;
    //
    //		    }
    //		    this.Route.add(this.Route.size(),ZK.G); 			// fügt am Ende der Liste die Größe G
    // (entspricht der Länge des Weges) ein
    //	    }
    //	    else //ansonsten
    //	    	this.Route.clear(); 								// Liste leeren
    //	}

    // Wegstrecke speichern
    Wegstrecke = ZK.G;
    // speichert Knoten in Array
    if (!open_L.isEmpty()) { // Wenn Zielknoten gefunden
      Knoten Knoten1 = ZK;
      while (Knoten1 != SK) { // "Gehe Weg Rückwärts" und speicher die zu begehenden Knoten
        this.Route.add(0, Knoten1);
        Knoten1 = Knoten1.Vorg;
      }
      this.Route.add(0, SK);
    } else // ansonsten
    this.Route.clear(); // Liste leeren
  }