import java.util.*;
/**
 * Graph. servus.
 */

public class Graph
{
    //Attribute
    private Knoten[] knotenliste;
    private int maxAnzahl;
    private int anzahl;

    private boolean[][] adjazenzmatrix;

    //Konstruktor
    public Graph(int maxAnzahl)
    {
          this.maxAnzahl = maxAnzahl;
        anzahl = 0;
        knotenliste = new Knoten[maxAnzahl];
        adjazenzmatrix = new boolean[maxAnzahl][maxAnzahl];
    }

    //Methoden
    /**
     *  Falls die maximale Knotenanzahl noch nicht erreicht ist, 
     *  wird ein neuer Knoten mit dem bergebenen Inhalt erzeugt
     *  und in die knotenliste eingefgt. 
     *  anzahl wird dann um ein erhht.
     *  
     *  @param inhalt Eine Zeichenkette, die im Knoten gespeichert werden soll.
     */
    public void  knotenEinfuegen(String inhalt)
    {
        Knoten k = new Knoten(inhalt);
        
        // Hier gibt es etwas zu tun        
    }

    /**
     * Prft ob der bergebene Inhalt in einem Knoten gespeichert ist und gibt dessen Nummer zurck.
     * Falls der Inhalt nicht gespeichert ist, soll -1 zurckgegeben werden.
     * 
     *   @param inhalt  Nach dieser Zeichenkette wird gesucht
     *   @return        Falls die Suche erfolgreich war, wird die Knotennr. zurckgegeben, ansonsten -1
     */
    public int knotennummerGeben(String inhalt)
    {
        // Hier gibt es etwas zu tun
        return 0;
    }         

    /**
     * Gibt eine Liste mit allen Knotennamen als String zurck
     */    
    public String alleKnoten()
    {
        String s = "";
        // Hier gibt es etwas zu tun
        return s;
    }

    /**
     * Fgt eine gerichtete Kante zwischen den Knoten mit den Inhalten bez1 und bez2 ein.
     * Falls es zu einem Bezeichner keinen Knoten geben sollte, wird eine Fehlermeldung
     * auf der Konsole ausgegeben.
     * 
     * @param bez1, bez2  Die Inhalte der beiden Knoten
     */
    public void kanteEinfuegen(String bez1, String bez2)
    {
       // Hier gibt es etwas zu tun
    }

    /**
     * Fgt eine ungerichtete Kante zwischen den Knoten mit den Inhalten bez1 und bez2 ein.
     */
    public void ungerichteteKanteEinfuegen(String bez1, String bez2)
    {
// Hier gibt es etwas zu tun
    }

    /**
     * Entfernt eine Kante zwischen zwei Knoten mit den Inhalten bez1 und bez2
     */
    public void kanteEntfernen(String bez1, String bez2)
    {
        // Hier gibt es etwas zu tun
    }
    
    /**
     * berprft, ob es zwischen den beiden Knoten mit den Bezeichnern bez1 und bez2 eine Kante gibt.
     */
    
    public boolean istKante(String bez1, String bez2)
    {
        // Hier gibt es etwas zu tun
        return true;
    }
  
    /**
     * Liefert die knotenliste zurck (Getter)
     */
    public Knoten[] getKnotenliste()
    {
        return knotenliste;
    }

    /**
     * Liefert die Adjazenzmatrix zurck
     */
    public boolean[][] getAdjazenzmatrix()
    {
        return adjazenzmatrix;
    }
    
    /**
     * Liefert die Knotenanzahl zurck
     */

    public int getKnotenAnzahl()
    {
        return anzahl;
    }

    /**
     *  Liefert den Knoten zu einem gegebenen Bezeichner zurck.
     */
    public Knoten getKnoten(String bez)
    {
        for (Knoten knoten: knotenliste)
        {
            if (knoten.getInhalt().equals(bez))
            {
                return knoten;
            }
        }
        return null;
    }
    
    /**
     * Algorithmus tiefensuche
     */
    public ArrayList tiefenSuche(String a)
    {
        ArrayList reihenfolge = new ArrayList();
        int k1 = knotennummerGeben(a);
        // Alle Knoten als unbesucht markieren
        for (int i = 0; i < anzahl; i++)
        {
            knotenliste[i].setMarke(false);
        }
        
        
        //Aufruf der rekursiven Suchmethode
        tiefensucheKnoten(k1,reihenfolge);
        return reihenfolge;
        
    }
    
    
    public void tiefensucheKnoten(int start, ArrayList reihenfolge)
    {
        //System.out.println("Knoten " + knotenliste[start].getInhalt());
        reihenfolge.add("+ " + knotenliste[start].getInhalt());
        knotenliste[start].setMarke(true);
        
        for (int i = 0; i < anzahl; i++)
        {
            if (adjazenzmatrix[start][i] && !knotenliste[i].getMarke())
            {
                tiefensucheKnoten(i,reihenfolge);
            }
        }
        reihenfolge.add("-" + knotenliste[start].getInhalt());
    }


}