Untersuchen ob ein Graph nach entfernen einer Kante immer noch zusammenhängend ist

M

Mika34

Bekanntes Mitglied
Hallo an alle,

Ich melde mich heute wieder zu später Stunde, um euch nach einen Rat zu fragen. Ich habe vor zwei Tagen eine ähnliche Frage gehabt, in der ich mit der Modellierung von einer Breiten -und Tiefensuche Probleme hatte.
Jetzt erschließt sich mir ein weiteres Problem.
Ich habe den Code soweit durch eure Hilfe mir zusammenbauen können, jedoch stoße ich an die nächste Wand, wo ich nicht weiter komme.
Der Code sieht momentan so aus:
Java:
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class ConstructionWorker<T> {
    private Map<T, List<T>> edgesBetweenTwoPoints = new HashMap<>();

    public void addEdge(T firstCoordinate, T secondCoordinate) {
        edgesBetweenTwoPoints.computeIfAbsent(firstCoordinate, x -> new ArrayList<T>());
        edgesBetweenTwoPoints.get(firstCoordinate).add(secondCoordinate);
        edgesBetweenTwoPoints.computeIfAbsent(secondCoordinate, x -> new ArrayList<T>());
        edgesBetweenTwoPoints.get(secondCoordinate).add(firstCoordinate);
    }

    public List<T> getEdges(T node) {
        return Collections.unmodifiableList(edgesBetweenTwoPoints.get(node));
    }

    public boolean isConnected() {
        if (edgesBetweenTwoPoints.isEmpty()) { return true; }
        Set<T> nodes = new HashSet<>(edgesBetweenTwoPoints.keySet());
        Iterator<T> it = nodes.iterator();
        if (it.hasNext()) {
            visitAndRemove(nodes, it.next());
        }
        return nodes.isEmpty();
    }

    private void visitAndRemove(Set<T> nodes, T node) {
        if (nodes.contains(node)) {
            nodes.remove(node);
            List<T> nextNodes = getEdges(node);
            for (T next : nextNodes) {
                visitAndRemove(nodes, next);
            }
        }
    }
}
Hierbei habe ich jedoch ein Problem, dass ich die Methoden nicht insofern verändern kann, dass beispielsweise der skizzierte Graph über die Knoten
A----B----C------D---E
verbunden ist und wenn man nun den Knoten D entfernt, dass der Graph dann nicht mehr zusammenhängend ist.
Hat jemand von euch eine Idee oder eine Richtung, wie sich dies implementieren lässt?
Wie immer bin ich tierisch dankbar über jede Hilfe! :)[/CODE]
 
H

httpdigest

Top Contributor
Deine Implementierung ist eigentlich korrekt, so wie sie ist.
Hierbei habe ich jedoch ein Problem, dass ich die Methoden nicht insofern verändern kann, dass beispielsweise der skizzierte Graph über die Knoten verbunden ist und wenn man nun den Knoten D entfernt, dass der Graph dann nicht mehr zusammenhängend ist.
Du hast in deinem Satz leider viele Verneinungen verwendet, so dass ich gar nicht weiß, was genau du eigentlich möchtest, bzw. was nun genau nicht funktioniert.
Ich denke, das Problem wird sein, wie du denn eigentlich Knoten aus dem Graph genau entfernst. Das fehlt leider in deinem Code.

EDIT: Das Entfernen von Kanten und auch Knoten müsste in etwa so aussehen:
Java:
public void removeEdge(T fst, T snd) {
  edgesBetweenTwoPoints.getOrDefault(fst, Collections.emptyList()).remove(snd);
  edgesBetweenTwoPoints.getOrDefault(snd, Collections.emptyList()).remove(fst);
}
public void removeVertex(T v) {
  edgesBetweenTwoPoints.remove(v);
  for (List<T> dest : edgesBetweenTwoPoints.values()) {
    dest.remove(v);
  }
}
 
Zuletzt bearbeitet:
M

Mika34

Bekanntes Mitglied
Deine Implementierung ist eigentlich korrekt, so wie sie ist.

Du hast in deinem Satz leider viele Verneinungen verwendet, so dass ich gar nicht weiß, was genau du eigentlich möchtest, bzw. was nun genau nicht funktioniert.
Ich denke, das Problem wird sein, wie du denn eigentlich Knoten aus dem Graph genau entfernst. Das fehlt leider in deinem Code.

EDIT: Das Entfernen von Kanten und auch Knoten müsste in etwa so aussehen:
Java:
public void removeEdge(T fst, T snd) {
  edgesBetweenTwoPoints.getOrDefault(fst, Collections.emptyList()).remove(snd);
  edgesBetweenTwoPoints.getOrDefault(snd, Collections.emptyList()).remove(fst);
}
public void removeVertex(T v) {
  edgesBetweenTwoPoints.remove(v);
  for (List<T> dest : edgesBetweenTwoPoints.values()) {
    dest.remove(v);
  }
}
Ja, genau. Mein Problem war es, wie ich überhaupt die Knoten aus meinem Graphen entfernt bekomme.
Aber mit der Methode "removeVertex" entferne ich nun den Knoten im Graphen und im gleichen Schritt, dann auch die dazugehörigen Kanten, welche damit verbunden sind. Unter der Annahme, das ich deinen Code richtig gelesen habe.
Oder verstehe ich das falsch?
Aber dann wird mir nicht ersichtlich, wieso es dann noch eine "removeEdge" Methode geben muss, wenn man diese ohnehin mit der "removeVertex" Methode tun kann.
 
H

httpdigest

Top Contributor
removeEdge() ist dann wichtig, wenn du eben nur eine Kante entfernen möchtest, und nicht gleich den ganzen Knoten. Das ist sinnvoll, wenn ein Knoten mehr als nur eine Kante zu anderen Knoten hat.
 
M

Mika34

Bekanntes Mitglied
Achso, so erschließt es sich.
Dabei ist mir gerade ein anderes Problem aufgefallen an der Implementierung. Wenn ich prüfen will, ob der Graph nach dem Entfernen eines Knotens streng zusammenhängend ist, dann muss ich
1.)den Knoten zwischenspeichern
2.)dann den Knoten entfernen
3.)dann prüfen, ob er immer noch zusammenhängend ist
Falls er nun noch zusammenhängend ist, dann kann ich die momentane Situation so belassen. Aber falls der Graph nicht mehr zusammenhängend ist, dann muss ich den gezwischenspeicherten Wert wieder in den Graphen einfügen.

Ist das der Weg, den man mittels dieser Implementierung verfolgen sollte oder könnte man das strukturierter und sinnvoller implementieren?
 
H

httpdigest

Top Contributor
Um zu prüfen, ob ein beliebiger Graph zusammenhängend ist (egal, wie viele Knoten und Kanten du vorher oder nachher hinzugefügt oder entfernt hast), musst du das machen, was du bereits tust:
1. suche dir irgendeinen der Knoten im Graphen aus
2. führe eine Tiefensuche oder Breitensuche von diesem Knoten ausgehend durch den Graphen aus
3. merke dir alle durch diese Suche erreichten Knoten in einer Menge
Wenn diese Menge dieselbe ist wie die der aktuell im Graphen gespeicherten Knoten, dann ist der Graph zusammenhängend.
 
M

Mika34

Bekanntes Mitglied
Aber dann muss ich einen Knoten zunächst entfernen, um an die Zweite Menge zu kommen, was ohne nicht möglich wäre. Oder wie ist das zu verstehen?
 
H

httpdigest

Top Contributor
Ach so, ich glaube, ich verstehe jetzt erst, was deine eigentlich Frage ist. Wenn du prüfen möchtest, ob ein Graph, der zum aktuellen Zeitpunkt noch zusammenhängend ist, auch nach dem hypothetischen Entfernen einer Kanten immer noch zusammenhängend sein würde, dann musst du einfach nur deine Tiefensuche entsprechend anpassen, dass sie eben nicht über die hypothetisch zu entfernende Kante traversiert. Du benötigst streng genommen also eine neue Methode, die die hypothetisch zu entfernende Kante als Parameter bekommt und als Rückgabewert einen boolean zurückliefert, der angibt, ob nach Entfernen dieser Kante der Graph noch zusammenhängend wäre (so er es denn schon vorher war).
 
M

Mika34

Bekanntes Mitglied
Ja genau. Also die Ausgangslage ist ein zusammenhängender Graph. Und nun soll ich prüfen, ob das Entfernen einer Kante aus dem zusammenhängenden Graphen einen nicht Zusammenhängenden macht.
Und wenn das eintritt, genau dann darf keine Kante entfernt werden. Also das ist mein Problem, wo ich gerade einfach nicht weiter komme und nicht verstehe, wie das auf Grundlage meiner bisherigen Implementierung umzusetzen ist.
 
A

abc66

Top Contributor
Mit Guava geht das recht einfach:
Java:
import java.util.ArrayList;
import java.util.HashSet;
import com.google.common.graph.MutableValueGraph;
import com.google.common.graph.ValueGraphBuilder;

public class Test {
	
	public static void main(String[] args) {
		MutableValueGraph<String, Float> graph = ValueGraphBuilder.directed().build();
		graph.addNode("Hamburg");
		graph.addNode("Berlin");
		graph.addNode("Dresden");
		graph.addNode("München");
		graph.addNode("FFM");
		graph.addNode("Essen");
		graph.putEdgeValue("Hamburg", "Essen", 372.3f);
		graph.putEdgeValue("Hamburg", "Berlin", 288.8f);
		graph.putEdgeValue("Berlin", "Dresden", 193.2f);
		graph.putEdgeValue("Dresden", "Berlin", 193.2f);
		graph.putEdgeValue("Dresden", "München", 459.7f);
		graph.putEdgeValue("FFM", "Essen", 250.0f);

		ArrayList<String> set1 = new ArrayList<String>();
		set1.add("Hamburg"); // Wähle ersten node
		HashSet<String> set2 = new HashSet<String>(graph.nodes());
		while (!set1.isEmpty()) {
			String s = set1.remove(0);
			if (set2.remove(s)) {
				for (String t : graph.adjacentNodes(s)) {
					if (graph.hasEdgeConnecting(s, t)) {
						set1.add(t);
					}
				}
			}
		}
		System.out.println(set1);
		System.out.println(set2);
		System.out.println(set2.isEmpty());
	}
	
}
 
H

httpdigest

Top Contributor
Also das ist mein Problem, wo ich gerade einfach nicht weiter komme und nicht verstehe, wie das auf Grundlage meiner bisherigen Implementierung umzusetzen ist.
Wenn du prüfen möchtest, ob ein Graph, der zum aktuellen Zeitpunkt noch zusammenhängend ist, auch nach dem hypothetischen Entfernen einer Kanten immer noch zusammenhängend sein würde, dann musst du einfach nur deine Tiefensuche entsprechend anpassen, dass sie eben nicht über die hypothetisch zu entfernende Kante traversiert. Du benötigst streng genommen also eine neue Methode, die die hypothetisch zu entfernende Kante als Parameter bekommt und als Rückgabewert einen boolean zurückliefert, der angibt, ob nach Entfernen dieser Kante der Graph noch zusammenhängend wäre (so er es denn schon vorher war).

Java:
import java.util.*;
public class Graph<T> {
  private final Map<T, List<T>> es = new HashMap<>();

  public void addEdge(T fst, T snd) {
    es.computeIfAbsent(fst, x -> new ArrayList<T>()).add(snd);
    es.computeIfAbsent(snd, x -> new ArrayList<T>()).add(fst);
  }
  public boolean isConnectedAfterRemoving(T fst, T snd) {
    if (es.isEmpty())
      return true;
    Set<T> notVisited = new HashSet<T>(es.keySet());
    visit(es.keySet().iterator().next(), notVisited, fst, snd);
    return notVisited.isEmpty();
  }
  private void visit(T next, Set<T> notVisited, T fst, T snd) {
    if (!notVisited.remove(next))
      return;
    for (T t : es.get(next))
      if ((next != fst || t != snd) && (next != snd || t != fst))
        visit(t, notVisited, fst, snd);
  }
  // Test
  public static void main(String[] args) {
    Graph<Integer> g = new Graph<>();
    g.addEdge(1, 2);
    g.addEdge(1, 3);
    g.addEdge(2, 3);
    g.addEdge(3, 4);
    System.out.println(g.isConnectedAfterRemoving(2, 3));
    System.out.println(g.isConnectedAfterRemoving(3, 4));
  }
}
 
Zuletzt bearbeitet:
A

abc66

Top Contributor
Sorry nochmal was geändert:
Java:
import java.util.ArrayList;
import java.util.HashSet;

import com.google.common.graph.MutableValueGraph;
import com.google.common.graph.ValueGraphBuilder;

public class Test {

	static boolean isStronglyConnectedComponent(MutableValueGraph<String, Float> g) {
		for (String n : g.nodes()) {
			ArrayList<String> list1 = new ArrayList<String>();
			list1.add(n); // Wähle ersten node
			HashSet<String> set2 = new HashSet<String>(g.nodes());
			while (!list1.isEmpty()) {
				String s = list1.remove(0);
				if (set2.remove(s)) {
					for (String t : g.adjacentNodes(s)) {
						if (g.hasEdgeConnecting(s, t)) {
							list1.add(t);
						}
					}
				}
			}
			if (!set2.isEmpty()) {
				return false;
			}
		}
		return true;
	}

	public static void main(String[] args) {
		MutableValueGraph<String, Float> graph = ValueGraphBuilder.directed().build();
		graph.addNode("Hamburg");
		graph.addNode("Berlin");
		graph.addNode("Dresden");
		graph.addNode("München");
		graph.addNode("FFM");
		graph.addNode("Essen");
		graph.putEdgeValue("Essen", "Hamburg", 372.3f);
		graph.putEdgeValue("Hamburg", "Essen", 372.3f);
		graph.putEdgeValue("Hamburg", "Berlin", 288.8f);
		graph.putEdgeValue("Berlin", "Dresden", 193.2f);
		graph.putEdgeValue("Dresden", "Berlin", 193.2f);
		graph.putEdgeValue("Dresden", "München", 459.7f);
		graph.putEdgeValue("FFM", "Essen", 250.0f);
		graph.putEdgeValue("Essen", "FFM", 250.0f);
		System.out.println(isStronglyConnectedComponent(graph));
		graph.putEdgeValue("München", "FFM", 392.1f);
		System.out.println(isStronglyConnectedComponent(graph));
	}

}
 
M

Mika34

Bekanntes Mitglied
Schönen Mittag nochmal,

Ich habe gestern Abend es versucht zu implementieren, jedoch sitze ich bis jetzt immer noch dran, weil es nicht funktioniert wie es soll.
Mein Problem ist momentan, dass ich Koordinaten entfernen möchte, bzw. hinzufügen möchte und dies mir gerade höllisch Probleme bereitet. Bis jetzt, sieht die Modellierung wie folgt aus, in Abwandlung zu httpdigest seinem Code
Java:
public class CartesianPoint <T>{
    private int xCoordinate;
    private int yCoordinate;
    private boolean isConnected;
    
    public CartesianPoint(int xCoordinate, int yCoordinate) {
        this.xCoordinate = xCoordinate;
        this.yCoordinate = yCoordinate;
    }
    
   private Map<T, List<T>> edgesBetweenTwoPoints = new HashMap<>();
    
    public void addEdge(T firstCoordinate, T secondCoordinate) {
        edgesBetweenTwoPoints.computeIfAbsent(firstCoordinate, x -> new ArrayList<T>()).add(secondCoordinate);
        edgesBetweenTwoPoints.computeIfAbsent(secondCoordinate, x -> new ArrayList<T>()).add(firstCoordinate);
    }

    
    public boolean isConnectedAfterRemoving(T fst, T snd) {
        if (edgesBetweenTwoPoints.isEmpty())
          return true;
        Set<T> notVisited = new HashSet<T>(edgesBetweenTwoPoints.keySet());
        visit(edgesBetweenTwoPoints.keySet().iterator().next(), notVisited, fst, snd);
        return notVisited.isEmpty();
      }
    
    private void visit(T next, Set<T> notVisited, T fst, T snd) {
        if (!notVisited.remove(next))
          return;
        for (T t : edgesBetweenTwoPoints.get(next))
          if ((next != fst || t != snd) && (next != snd || t != fst))
            visit(t, notVisited, fst, snd);
      }

}
 
H

httpdigest

Top Contributor
Du bringst hier glaube ich in der Modellierung etwas durcheinander: Dein Graph ist kein kartesicher Punkt, sondern er enthält Punkte, bzw. er enthält Kanten zwischen jeweils zwei Punkten.
Dementsprechend würde ich stattdessen eine Klasse "Graph<T>" schreiben und eine separate Klasse "CartesianPoint". Dann kannst du für T im Graph die Klasse CartesianPoint verwenden. Du hast dann also ein "Graph of CartesianPoint(s)".
 
M

Mika34

Bekanntes Mitglied
Du bringst hier glaube ich in der Modellierung etwas durcheinander: Dein Graph ist kein kartesicher Punkt, sondern er enthält Punkte, bzw. er enthält Kanten zwischen jeweils zwei Punkten.
Dementsprechend würde ich stattdessen eine Klasse "Graph<T>" schreiben und eine separate Klasse "CartesianPoint". Dann kannst du für T im Graph die Klasse CartesianPoint verwenden. Du hast dann also ein "Graph of CartesianPoint(s)".
Ok, das habe ich nun gemacht, das war aber auch sehr schwachsinnig. Aber nun habe ich das Problem, dass die Methode isConnected nicht dahingehend funktioniert, dass sie erkennt wenn ein Graph so aufgebaut ist:
A-----B-----C----D
Wenn man hier nun die Kante von C nach D entfernt, dann ist der Graph trotzdem noch streng zusammenhängend, jedoch gibt mir die Methode durchgehend ein false zurück, dass dieser nicht mehr zusammenhängend ist. Denn wenn ich hier die Kante entferne, entferne ich automatisch auch den Knoten D. Ich hab das in einem Beispiel ausprobiert und meine Modellierung angepasst.
Java:
public class Graph <T> {

    private Map<T, List<T>> edgesBetweenTwoPoints = new HashMap<>();
    
    public void addEdge(T firstCoordinate, T secondCoordinate) {
        edgesBetweenTwoPoints.computeIfAbsent(firstCoordinate, x -> new ArrayList<T>()).add(secondCoordinate);
        edgesBetweenTwoPoints.computeIfAbsent(secondCoordinate, x -> new ArrayList<T>()).add(firstCoordinate);
    }

    
    public boolean isConnectedAfterRemoving(T fst, T snd) {
        if (edgesBetweenTwoPoints.isEmpty())
          return true;
        Set<T> notVisited = new HashSet<T>(edgesBetweenTwoPoints.keySet());
        visit(edgesBetweenTwoPoints.keySet().iterator().next(), notVisited, fst, snd);
        return notVisited.isEmpty();
      }
    
    private void visit(T next, Set<T> notVisited, T fst, T snd) {
        if (!notVisited.remove(next))
          return;
        for (T t : edgesBetweenTwoPoints.get(next))
          if ((next != fst || t != snd) && (next != snd || t != fst))
            visit(t, notVisited, fst, snd);
      }
    
    
    public static void main(String[] args) {
        TrackRemover<CartesianPoint> g = new TrackRemover<>();
        CartesianPoint p1 = new CartesianPoint(1,1);
        CartesianPoint p2 = new CartesianPoint(5,1);
        CartesianPoint p3 = new CartesianPoint(8,1);
        CartesianPoint p4 = new CartesianPoint(10,1);

        g.addEdge(p1, p2);
        g.addEdge(p2, p3);
        g.addEdge(p3, p4);

        System.out.println(g.isConnectedAfterRemoving(p3, p4));
      }
}
 
H

httpdigest

Top Contributor
Wenn man hier nun die Kante von C nach D entfernt, dann ist der Graph trotzdem noch streng zusammenhängend, jedoch gibt mir die Methode durchgehend ein false zurück, dass dieser nicht mehr zusammenhängend ist. Denn wenn ich hier die Kante entferne, entferne ich automatisch auch den Knoten D.
Für die Methode gilt ein Knoten nicht automatisch als entfernt, nur weil du die letzte Kante zu ihm entfernt hast. Das ist dann auch Definitionssache. Ein Knoten kann ja auch ohne Kante in einem Graphen existieren. Wenn du das nicht möchtest, musst du die Methoden isConnectedAfterRemoving() und visit() noch etwas anpassen, dass sie den bzw. die entfernten Knoten nicht mehr berücksichtigen.
 
M

Mika34

Bekanntes Mitglied
Für die Methode gilt ein Knoten nicht automatisch als entfernt, nur weil du die letzte Kante zu ihm entfernt hast.
Ich habe den Knoten in einer anderen Map gelöscht, in dem ich Objekte gespeichert habe, jedoch komme ich nicht an die Knoten in der Klasse Graph dran, da diese gar nicht in der Modellierung vorkommen.
In meiner anderen Map, sind diese durch startX und startY Koordinaten bestimmt. Hier habe ich auf die keinen Zugriff, wodurch sich dieser nicht entfernen lässt.
 
H

httpdigest

Top Contributor
Ich habe den Knoten in einer anderen Map gelöscht, in dem ich Objekte gespeichert habe, jedoch komme ich nicht an die Knoten in der Klasse Graph dran, da diese gar nicht in der Modellierung vorkommen.
In meiner anderen Map, sind diese durch startX und startY Koordinaten bestimmt. Hier habe ich auf die keinen Zugriff, wodurch sich dieser nicht entfernen lässt.
Wovon redest du? Meine Aussage war nur, dass aktuell die Methode isConnectedAfterRemoving() nicht berücksichtigt, dass Knoten komplett aus dem Graph entfallen, wenn sie nur noch eine Kante zu anderen Knoten besitzen und diese Kante gelöscht werden würde.
Um das zu berücksichtigen, kann man die Methode wie folgt anpassen:
Java:
public boolean isConnectedAfterRemoving(T fst, T snd) {
  Set<T> notVisited = new HashSet<T>(edgesBetweenTwoPoints.entrySet().stream()
      .filter(e -> e.getValue().stream()
          .filter(d -> !d.equals(fst) && !d.equals(snd))
          .count() > 0)
      .map(Map.Entry::getKey)
      .collect(java.util.stream.Collectors.toSet()));
  if (notVisited.isEmpty())
    return true;
  visit(notVisited.iterator().next(), notVisited, fst, snd);
  return notVisited.isEmpty();
}
EDIT: Kleinen Bug gefixed. :)
 
Zuletzt bearbeitet:
M

Mika34

Bekanntes Mitglied
Oh je, ich glaube ich bringe hier ziemlich viel durcheinander.
Wenn ich einen Graphen habe der so aussieht:
A-----B-----C----D
und ich entferne die Kante C----D, dann bleibt dies übrig
A-----B-----C
Jedoch verstehe ich nicht wie sich das implementieren lässt oder, ob das überhaupt möglich ist unter gegebener Modellierung meinerseits
 
H

httpdigest

Top Contributor
Jedoch verstehe ich nicht wie sich das implementieren lässt oder, ob das überhaupt möglich ist unter gegebener Modellierung meinerseits
Ist möglich. Siehe Code oben. :) Du brauchst einfach nur zu prüfen, ob ein Knoten keine Kante mehr besitzen würde, nachdem die zu entfernende Kante entfernt werden würde.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
M Bitmap untersuchen, etc. Java Basics - Anfänger-Themen 1
M Matrix auf 4 Elemente untersuchen mit offenen Enden Java Basics - Anfänger-Themen 8
L String auf bestimmte zeichen untersuchen Java Basics - Anfänger-Themen 9
Y String auf allgemein Zeichen untersuchen Java Basics - Anfänger-Themen 3
M Aus Datei auslesen und untersuchen ob diese Zeile schon vorhanden ist Java Basics - Anfänger-Themen 3
G 2 dimensionales Array spaltenweise untersuchen. Java Basics - Anfänger-Themen 2
H Spiel Kniffel: Gesamtes Array untersuchen. Java Basics - Anfänger-Themen 15
B Array rekursiv untersuchen Java Basics - Anfänger-Themen 21
M string arraylist untersuchen frage Java Basics - Anfänger-Themen 6
S String auf Sonderzeichen untersuchen Java Basics - Anfänger-Themen 6
L Textzeilen nach 2 Wörtern untersuchen wenn vorhanden Zeile in neuen Text ausgeben wenn nicht löschen Java Basics - Anfänger-Themen 10
G Mit Java Quelltext auf Element untersuchen. Java Basics - Anfänger-Themen 5
O ADT Graph nach größe Abfragen Java Basics - Anfänger-Themen 42
N gerichteter Graph aus einer Datei einlesen Java Basics - Anfänger-Themen 21
Z Graph einlesen Java Basics - Anfänger-Themen 2
S Ungerichteter Graph in Java Java Basics - Anfänger-Themen 1
M int double int double Graph Java Basics - Anfänger-Themen 3
A Tiefensuche in Graph Java Basics - Anfänger-Themen 4
N gerichteten Graph abspeichern Java Basics - Anfänger-Themen 2
Luk10 Frage zu Graph Tiefensuche Java Basics - Anfänger-Themen 4
S Methoden Wegsuche in einem Graph Java Basics - Anfänger-Themen 6
F Zusammenhängend Komponente suchen(Graph) Java Basics - Anfänger-Themen 4
F Kanten in Graph Java Basics - Anfänger-Themen 3
M Wth? übernimmt nichtübergebenen Wert (Graph) Java Basics - Anfänger-Themen 4
T Wie kann ich einem Graph in nem JPanel eine fixe Größe geben? Java Basics - Anfänger-Themen 6
H gerichteter Graph Java Basics - Anfänger-Themen 9
B Graph aus 2dim-Array Java Basics - Anfänger-Themen 3
G Primzahlen von Rekursiv nach Iterativ Java Basics - Anfänger-Themen 6
F JMenuItem Kann nicht nach einem String benannt werden... Java Basics - Anfänger-Themen 11
R JDK installieren Durcheinander nach installation von SE 14.02 Java Basics - Anfänger-Themen 6
P Sortieren von Listen nach Attributen Java Basics - Anfänger-Themen 3
B DateTimeFormatter nach LocalDateTime, wenn dd.MM.yyyy oder dd.MM.yyyy mm:hh Java Basics - Anfänger-Themen 5
1 main-Methode erweitern, Nachfrage nach wiedeholung Java Basics - Anfänger-Themen 2
G unklares Verhalten nach Instanzierung neuer Klasse Java Basics - Anfänger-Themen 3
S Wohin kommt das „abstract“? Vor oder nach „public“/ „private“ /... Java Basics - Anfänger-Themen 3
S Datenbank Befehl nach Login Java Basics - Anfänger-Themen 5
N Operatoren Schreibtischtest der Reihen-Suche nach Aufschluss in die Basics Java Basics - Anfänger-Themen 1
B Umstieg von C# nach Java Java Basics - Anfänger-Themen 18
Ellachen55 Wie nach häufigste Werte im Array suchen? Java Basics - Anfänger-Themen 2
N Wörter und Zahlen nach speziellen Wörtern ausgeben Java Basics - Anfänger-Themen 11
M Werte ändern sich nicht mehr nach Reset Java Basics - Anfänger-Themen 14
B Nach dem kompilieren werden Bilder nicht mehr gefunden Java Basics - Anfänger-Themen 10
X Nach einem Bruch testen ob es eine ganze Zahl ist Java Basics - Anfänger-Themen 6
B String nach erstem Leerzeichen trennen Java Basics - Anfänger-Themen 7
N Speichern von Werten in Variablen nach Schließen des Programms Java Basics - Anfänger-Themen 3
G String wird nach Einlesen aus Datei nicht erkannt Java Basics - Anfänger-Themen 3
UnknownInnocent Best Practice Algorithmus nach jedem Schritt zum Visualisieren pausieren Java Basics - Anfänger-Themen 3
O zwei Arrays nach Werten durchsuchen und zusammenfügen Java Basics - Anfänger-Themen 3
M Double Wert nach n abschneiden ohne zu runden Java Basics - Anfänger-Themen 1
C Erste Schritte Bilder nach Export anzeigen Java Basics - Anfänger-Themen 0
F Input/Output Files von A nach B kopieren Java Basics - Anfänger-Themen 11
B InputStream (PDF) nach Image (PNG / JPG) konvertieren? Java Basics - Anfänger-Themen 2
O compareTo nach mehreren Kriterien Java Basics - Anfänger-Themen 13
R Benutzereingaben als Array abspeichern nach Programmstart Java Basics - Anfänger-Themen 5
S Pane nach speziellen Child Objekten durchsuchen Java Basics - Anfänger-Themen 3
V Neue Ausgabe von toString nach Methodenaufruf Java Basics - Anfänger-Themen 9
L Arrayliste von hinten nach vorne ausgeben Java Basics - Anfänger-Themen 10
F Array nach Objektattribut durchsuchen Java Basics - Anfänger-Themen 6
M Rationale Zahl erkennen - Kurze Frage zum Restwert nach Division Java Basics - Anfänger-Themen 3
O String von vorne nach hinten an einem Zeichen Java Basics - Anfänger-Themen 10
Hanschyo Quicksort sortiert von groß nach klein Java Basics - Anfänger-Themen 3
S suche nach varible POSITION ... fuer das pixel-maennchen Java Basics - Anfänger-Themen 4
A Einträge aus Tupeln nach Regeln in Liste speichern Java Basics - Anfänger-Themen 8
B String nach HTML formatieren Java Basics - Anfänger-Themen 9
Zrebna Compiler-Fehler Java-Compiler wird nach 'javac' keyword-Eingabe nicht gestartet (Erste Übung) Java Basics - Anfänger-Themen 18
UnknownInnocent Klassen JPanel nach Ablauf der Spielzeit neuladen Java Basics - Anfänger-Themen 2
B Umbruch nach bestimmten Wort Java Basics - Anfänger-Themen 5
E Arrays nach best Muster füllen Java Basics - Anfänger-Themen 4
N Arbeitsspeicher nach kompilieren immer voller Java Basics - Anfänger-Themen 6
K String nach bestimmtem Muster parsen Java Basics - Anfänger-Themen 3
S Amazon Produktbeschreibung auslesen und nach Keywords suchen Java Basics - Anfänger-Themen 2
M Scanner-Eingabe nach gewissem Zeitraum überprüfen Java Basics - Anfänger-Themen 2
J variablePathPart ändern nach dem Ordner abgearbeitet worden ist Java Basics - Anfänger-Themen 1
B Wie kann ich die Buchstaben sortieren nach der Höhe der Zahlen Java Basics - Anfänger-Themen 14
J GUI wird direkt nach dem erstellen weiß übermalt Java Basics - Anfänger-Themen 3
L Programm zur Codieren nach Rotx Java Basics - Anfänger-Themen 1
S Nach dem Herüberschieben eines Arrays zwischen 2 Frames öffnet sich das Frame nicht mehr Java Basics - Anfänger-Themen 12
A ArrayList - size() nur nach bestimmtem index anzeigen lassen Java Basics - Anfänger-Themen 13
M Array nach String durchsuchen und zurückgeben Java Basics - Anfänger-Themen 16
W Wie lasse ich meine Ausgabe nach dem Lesen verschwinden ? Java Basics - Anfänger-Themen 1
F Liste nach einer Variablen sortieren Java Basics - Anfänger-Themen 6
S String trennen nach beliebigen Zeichen Java Basics - Anfänger-Themen 3
D Ich suche nach einer Möglickeit den Webseiten Inhalt per Java zu analysieren Automatisch Java Basics - Anfänger-Themen 3
B String: suche nach Wörter und in List<String> speichern Java Basics - Anfänger-Themen 3
O Array nach gleichen Zahlen prüfen und ausgeben Java Basics - Anfänger-Themen 6
K Matrixen berechnen nach Worker Master Paradigma mit Threads Java Basics - Anfänger-Themen 4
K Schlüsselworte Nach Java update findet mdb Datei nicht Java Basics - Anfänger-Themen 6
G nach 9 - stelliger Nummer suchen Java Basics - Anfänger-Themen 7
S Wie verwende ich ne aus einer Schleife nach der Schleife? Java Basics - Anfänger-Themen 9
M BufferedReader neue Zeile nach Knopfdruck Java Basics - Anfänger-Themen 9
E JAvaFX: Verschiedene Panels nach Klick auf Node des TreeView anzeigen Java Basics - Anfänger-Themen 0
D Liste nach 2 gleichen Einträgen suchen Java Basics - Anfänger-Themen 4
J Input/Output Den zweiten Output erst nach Eingabe ausgeben Java Basics - Anfänger-Themen 4
L (Integer) Liste nach aufsteigender Summe der Ziffern sortieren (mit Bedingung) Java Basics - Anfänger-Themen 8
S Dialogfeld nach 5 Sek automatisch öffnen Java Basics - Anfänger-Themen 15
F Alle Objekte einer Klasse nach Eigenschaft durchsuchen Java Basics - Anfänger-Themen 8
S OOP Button erst nach 2x klicken deaktivieren Java Basics - Anfänger-Themen 4
C Compiler-Fehler Wird eine if Bedingung nach einer for-Schleife nach jeder Iteration überprüft? Java Basics - Anfänger-Themen 1
F Koordinaten nach 360° auf 0° setzen Java Basics - Anfänger-Themen 2
N Operatoren Suchen nach einer bestimmten Eingabe (durch Scanner) Java Basics - Anfänger-Themen 7

Ähnliche Java Themen

Anzeige


Oben