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

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]
 

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:

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.
 

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.
 

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?
 

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.
 

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?
 

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).
 

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.
 

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());
	}
	
}
 

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:

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));
	}

}
 

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);
      }

}
 

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)".
 

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));
      }
}
 

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.
 

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.
 

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:

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
 

Mika34

Bekanntes Mitglied
Oh, Herr *facepalm*, du hast vollkommen Recht. Vielen Dank *erneutes facepalm*.
Jedoch habe ich noch eine kleine Verständnisfrage, falls es in Ordnung für dich ist.
Angenommen wir haben so einen Graphen:

Code:
A----B----C----D
          |
          |
          E
Und man entferne nun gleichzeitig die Kanten: C-----D und C
                                                         |
                                                         |
                                                         E
Wenn man nun auf die gleiche Frage prüft, ob der Graph nach dem gleichzeitigen Entfernen von diesen beiden Kanten immer noch zusammenhängend ist, geht man wie oben in deinem Code vor, oder wäre hier besondere Obacht geboten?
 

mihe7

Top Contributor
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

In der Map würde das so aussehen:
Java:
A->[B]
B->[A,C]
C->[B,D]
D->[C]

Die Schlüssel (links) bilden die Knotenmenge, also {A,B,C,D}. Jetzt beginnst Du mit dem Besuch eines beliebigen Knotens. Zum Beispiel B. Wenn Du einen Knoten besuchst, merkst Du Dir als erstes, dass Du diesen bereits besucht hast. Das ist wichtig, um Zyklen zu erkennen. Dann werden alle Kanten betrachtet und dabei die noch nicht besuchten Knoten besucht. Wenn am Ende die gesamte Knotenmenge besucht wurde, ist der Graph zusammenhängend.

Statt sich zu merken, welche Knoten man besucht hat, kann man sich auch merken, welche Knoten man noch nicht besucht hat (das macht der Algorithmus aus dem Eröffnungspost).

Wenn Du die Kante C-D entfernst, ändert sich die Map wie folgt:
Java:
A->[B]
B->[A,C]
C->[B]
D->[]
Es gibt nun keine Verbindung mehr von/zu D, was von dem Algorithmus erkannt werden würde -> nicht zusammenhängend.

Statt die Verbindung tatsächlich aus der Map zu entfernen, musst Du lediglich dafür sorgen, dass die betreffenden Kanten (C->D und D->C) nicht verarbeitet werden.

Was die Frage
Wenn man nun auf die gleiche Frage prüft, ob der Graph nach dem gleichzeitigen Entfernen von diesen beiden Kanten immer noch zusammenhängend ist, geht man wie oben in deinem Code vor, oder wäre hier besondere Obacht geboten?
beantworten dürfte :)
 

Mika34

Bekanntes Mitglied
Natürlich macht das total Sinn, da dies im Grunde auch nur eine Suche danach ist. Jedoch komme ich nicht auf den Weg, inwiefern man vorzugehen habe, wenn zwei Kanten auf einmal zu entfernen seien. Dies ist mir im Moment noch nicht total schlüssig geworden auf der Grundlage des Codes. Mein Ansatz wäre, dass man diesen Algorithmus zwei mal durchlaufen lässt und dann jeweils zwei booleans miteinander vergleicht und wenn beide auf true zeigen, hat sich die Sache erledigt und man kann beide entfernen.
Ist dies ein primitivier Ansatz oder gibt es einen Weg, welcher dies effizienter lösen würde?
Java:
    public boolean isConnectedAfterRemoving(T fst, T snd) {
        if (edgesBetweenTwoPoints.isEmpty())
          return true;
        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(e -> e.getKey())
            .collect(java.util.stream.Collectors.toSet()));
        visit(notVisited.iterator().next(), notVisited, fst, snd);
        return notVisited.isEmpty();
      }
 

mihe7

Top Contributor
Mein Ansatz wäre, dass man diesen Algorithmus zwei mal durchlaufen lässt und dann jeweils zwei booleans miteinander vergleicht und wenn beide auf true zeigen, hat sich die Sache erledigt und man kann beide entfernen.
Das liefert i. A. falsche Ergebnisse, weil beim zweiten Durchlauf die erste Kante wieder im Graph vorhanden ist.

gibt es einen Weg, welcher dies effizienter lösen würde?
Sicher, Du musst lediglich eine Menge von Kanten an die Methode übergeben und die betreffenden Kanten rausfiltern.
 

Mika34

Bekanntes Mitglied
Ich habe mich nun daran versucht, jedoch prüft die Methode nicht richtig, das heißt es wird durchweg ein falscher Wert zurückgegeben, mit dem ich nicht auf das gewünschte Ergebnis komme.
Ist mein Ansatz falsch oder geht es nur über einen anderen Weg?
Java:
   public boolean isConnectedAfterRemovingWithThree(T fst, T snd, T thrd) {
        if (edgesBetweenTwoPoints.isEmpty())
          return true;
        Set<T> notVisited = new HashSet<T>(edgesBetweenTwoPoints.entrySet().stream()
            .filter(e -> e.getValue().stream()
                .filter(d -> !d.equals(fst) && !d.equals(snd) && !d.equals(thrd))
                .count() > 0)
            .map(e -> e.getKey())
            .collect(java.util.stream.Collectors.toSet()));
        visitThreeEdges(notVisited.iterator().next(), notVisited, fst, snd, thrd);
        return notVisited.isEmpty();
      }

 private void visitThreeEdges(T next, Set<T> notVisited, T fst, T snd, T thrd) {
        if (!notVisited.remove(next))
          return;
        for (T t : edgesBetweenTwoPoints.get(next))
            if ((!next.equals(fst) || !t.equals(snd)) && (!next.equals(snd) || !t.equals(fst))&& (!next.equals(thrd) || !t.equals(fst))
                    && (!next.equals(fst) || !t.equals(thrd))&& (!next.equals(thrd) || !t.equals(snd))&& (!next.equals(snd) || !t.equals(thrd)))
                visitThreeEdges(t, notVisited, fst, snd, thrd);
      }
 

httpdigest

Top Contributor
Du musst dir erstmal im Klaren darüber werden, was es genau ist, das du aus dem Graphen entfernen möchtest. Möchtest du nun Kanten oder Knoten entfernen? Meine ursprüngliche Methode `isConnectedAfterRemoving(T fst, T snd)` ging davon aus, dass du die Kante zwischen den beiden Knoten `fst` und `snd` entfernen möchtest. Das führt nicht notwendigerweise zum Entfernen von `fst` oder `snd` als Knoten.
Unter dieser Annahme macht deine Erweiterung der Methode mit drei Parametern keinen Sinn.
 

Mika34

Bekanntes Mitglied
Doch ich möchte die Kante zwischen zwei Knoten entfernen, wie in diesem Beispiel:
A-----B-----C----D
ich entferne die Kante C----D, dann bleibt dies übrig
A-----B-----C
Der Kernaspekt, welchen ich verfolge ist, dass aus einem Graphen, welcher zusammenhängend ist, nicht zwei Teilgraphen entstehen, wie in diesem Beispiel. Hier dürfte man nicht eine Kante entfernen, da man dann zwei Graphen hat, ausgehend von einem Graphen, der zusammenhängend war:
A-----B-----C----D-----E----F
ich entferne die Kante C----D, dann bleibt dies übrig
A-----B-----C D----E-----F

Dabei bin ich dann ins Grübeln gekommen, wenn man zwei Kanten entfernen möchte, ausgehend von einem Knoten, ob man hier prüfen kann, ob nach dem Entfernen immer noch ein zusammenhängender Graph übrig bleibt und nicht zwei unabhängige Graphen wie im letzten Beispiel
 

httpdigest

Top Contributor
Doch ich möchte die Kante zwischen zwei Knoten entfernen, wie in diesem Beispiel:
Du möchtest also die Kante zwischen zwei Knoten entfernen, indem du drei Knoten angibst... das ergibt keinen Sinn.
Und wenn du hier meintest, dass du zwei Kanten testen/entfernen möchtest, dann werden zwei Kanten nicht durch drei Knoten definiert, sondern durch vier. Es sei denn natürlich, dass einer der Knoten von den beiden Kanten gemeinsam genutzt wurde.
By the way: Was du erreichen möchtest, ist mir schon klar, das hast du bereits dreimal ausführlich erklärt.
Mein Punkt ist nur, dass es keinen Sinn macht, zwei Kanten durch drei Knoten anzugeben.
 

Mika34

Bekanntes Mitglied
In meiner Modellierung kann ich Kanten nur senkrecht oder waagrecht setzen. Jeder Anfangspunkt und jeder Endpunkt einer Kante sind Knoten. Hierbei dürfen Kanten nur von einem anderen Anfangspunkt/Endpunkt einer anderen Kante beginnen bzw. aufhören. Deshalb möchte ich zwei Kanten durch drei Knoten modellieren, da ein Knoten, dann von zwei Kanten genutzt wird.
Das ist der Grund, weshalb ich drei Kanten durch zwei Knoten angebe.
Und hierbei bin ich noch auf keine eindeutige Lösung gekommen, wie man das richtig in die Tat umsetzen soll, bezogen auf das gleichzeitige Entfernen von zwei Kanten ausgehend von einem Knoten.
 

LimDul

Top Contributor
In meiner Modellierung kann ich Kanten nur senkrecht oder waagrecht setzen. Jeder Anfangspunkt und jeder Endpunkt einer Kante sind Knoten. Hierbei dürfen Kanten nur von einem anderen Anfangspunkt/Endpunkt einer anderen Kante beginnen bzw. aufhören. Deshalb möchte ich zwei Kanten durch drei Knoten modellieren, da ein Knoten, dann von zwei Kanten genutzt wird.
Das ist der Grund, weshalb ich drei Kanten durch zwei Knoten angebe.
Und hierbei bin ich noch auf keine eindeutige Lösung gekommen, wie man das richtig in die Tat umsetzen soll, bezogen auf das gleichzeitige Entfernen von zwei Kanten ausgehend von einem Knoten.
Das verstehe ich nicht? Ein Knoten ist keine Kante. Modelliere das als getrennte Objekte, dann wird es mit Sicherheit viel einfacher.
 

Mika34

Bekanntes Mitglied
Das verstehe ich nicht? Ein Knoten ist keine Kante. Modelliere das als getrennte Objekte, dann wird es mit Sicherheit viel einfacher.
Also so sollte ein Beispielgraph aussehen: .
Eine Kante darf nur auf einem Start bzw. Endpunkt einer anderen Kante beginnen und demnach wird ein Knoten zwei Kanten zugeordnet. Und wenn ich nun eine Kante entferne, sollen keine zwei Teilgraphen aus diesem entstehen. Das ist momentan die Modllierungsfrage
 

LimDul

Top Contributor
Dann hast du 12 Knoten Objekte (Jeweils mit x/y-Koordinate) und 13 Kanten-Objekte (jeweils mit 2 Knoten Objekten als Referenz)

Und dann kann man darauf all das vorher gesagt anwenden.
 

Mika34

Bekanntes Mitglied
Dann hast du 12 Knoten Objekte (Jeweils mit x/y-Koordinate) und 13 Kanten-Objekte (jeweils mit 2 Knoten Objekten als Referenz)

Und dann kann man darauf all das vorher gesagt anwenden.
Ja, genau. Diese Methode funktioniert auch schon, mit der Hilfe von httpdigest.
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();
}
Jedoch hapert es noch an der Stelle bei mir, wenn eine Weiche entfernt wird, sprich zwei Kanten auf einmal. Denn dann ist zu prüfen, ob der Graph nach dem Entfernen von zwei Kanten nicht in zwei Teilgraphen zerfällt.
 

Mika34

Bekanntes Mitglied
Nochmal schönen Abend an die, die noch wach sind.
Ich versuche mich nun seit Stunden an der besagten Methode, die zwei Kanten simultan entfernen soll, jedoch will es einfach nicht klappen. Er schaltet einfach nicht wie er soll.
Hat jemand von Euch eine Idee, wie ich dies implementieren kann, da meine Implementierung nur den Bach untergeht.
Darüber wäre ich tierisch dankbar.
 

mihe7

Top Contributor
Erstmal Kanten modellieren:
Java:
import java.util.*;

class Edge<T> {
    private final T source;
    private final T dest;

    public Edge(T source, T dest) {
        this.source = source;
        this.dest = dest;
    }

    @Override
    public boolean equals(Object o) {
        if (o == null || o == this || !(o instanceof Edge)) {
            return o == this;
        }

        Edge<?> edge = (Edge<?>) o;
        return Objects.equals(source, edge.source) &&
               Objects.equals(dest, edge.dest);
    }

    @Override
    public int hashCode() {
        return Objects.hash(source, dest);
    }
}

Und dann die Methoden anpassen:
Java:
    public boolean isConnectedAfterRemoving(Set<Edge<T>> toRemove) {
        Set<T> notVisited = new HashSet<T>(edgesBetweenTwoPoints.entrySet()
            .stream()
            .filter(e -> e.getValue().stream()
                .filter(d -> !toRemove.contains(new Edge<>(e, d)) &&
                             !toRemove.contains(new Edge<>(d, e)))
                .count() > 0)
            .map(Map.Entry::getKey)
            .collect(java.util.stream.Collectors.toSet()));
        if (notVisited.isEmpty())
            return true;
        visit(notVisited.iterator().next(), notVisited, toRemove);
        return notVisited.isEmpty();
    }

    private void visit(T next, Set<T> notVisited, Set<Edge<T>> toRemove) {
        if (!notVisited.remove(next))
          return;
        for (T t : edgesBetweenTwoPoints.get(next))
          if (!toRemove.contains(new Edge<>(next, t)) &&
              !toRemove.contains(new Edge<>(t, next)))
            visit(t, notVisited, toRemove);
    }
Achtung: der Spaß ist ungetestet.
 

Mika34

Bekanntes Mitglied
Erstmal Kanten modellieren:
Java:
import java.util.*;

class Edge<T> {
    private final T source;
    private final T dest;

    public Edge(T source, T dest) {
        this.source = source;
        this.dest = dest;
    }

    @Override
    public boolean equals(Object o) {
        if (o == null || o == this || !(o instanceof Edge)) {
            return o == this;
        }

        Edge<?> edge = (Edge<?>) o;
        return Objects.equals(source, edge.source) &&
               Objects.equals(dest, edge.dest);
    }

    @Override
    public int hashCode() {
        return Objects.hash(source, dest);
    }
}

Und dann die Methoden anpassen:
Java:
    public boolean isConnectedAfterRemoving(Set<Edge<T>> toRemove) {
        Set<T> notVisited = new HashSet<T>(edgesBetweenTwoPoints.entrySet()
            .stream()
            .filter(e -> e.getValue().stream()
                .filter(d -> !toRemove.contains(new Edge<>(e, d)) &&
                             !toRemove.contains(new Edge<>(d, e)))
                .count() > 0)
            .map(Map.Entry::getKey)
            .collect(java.util.stream.Collectors.toSet()));
        if (notVisited.isEmpty())
            return true;
        visit(notVisited.iterator().next(), notVisited, toRemove);
        return notVisited.isEmpty();
    }

    private void visit(T next, Set<T> notVisited, Set<Edge<T>> toRemove) {
        if (!notVisited.remove(next))
          return;
        for (T t : edgesBetweenTwoPoints.get(next))
          if (!toRemove.contains(new Edge<>(next, t)) &&
              !toRemove.contains(new Edge<>(t, next)))
            visit(t, notVisited, toRemove);
    }
Achtung: der Spaß ist ungetestet.
Aber dann wird in deiner Modellierung der Fall gar nicht aufgegriffen, wenn zwei Kanten zur gleichen Zeit entfernt werden oder habe ich ein riesiges Brett vor der Stirn
 

mihe7

Top Contributor
Aber dann wird in deiner Modellierung der Fall gar nicht aufgegriffen, wenn zwei Kanten zur gleichen Zeit entfernt werden oder habe ich ein riesiges Brett vor der Stirn
Du übergibst an isConnectedAfterRemoving eine Menge von Kanten, so dass Du prüfen kannst, ob der Graph nach der Entfernung einer beliebigen Anzahl von Kanten noch zusammenhängend wäre.
 

DagobertDuck

Bekanntes Mitglied
@mihe7 Wenn man für ein Projekt als Kantentyp z. B. nur <Point> braucht, sollte man dann auch als Typ-Parameter <Point> nehmen, oder ist es besserer Programmierstil, wenn man <T> nimmt, sodass es später ggf. noch angepasst werden kann?
 

DagobertDuck

Bekanntes Mitglied
Oder z. B. private Map<Point, List<Point>> edgesBetweenTwoPoints = new HashMap<>(); anstatt private Map<T, List<T>> edgesBetweenTwoPoints = new HashMap<>(); .
 

mihe7

Top Contributor
T kannst Du nur nehmen, wenn die Klasse einen Typparameter T hat.
Java:
class X<T> {
   private Map<T, List<T>> edges;
}
 

Mika34

Bekanntes Mitglied
Erstmal Kanten modellieren:
Java:
import java.util.*;

class Edge<T> {
    private final T source;
    private final T dest;

    public Edge(T source, T dest) {
        this.source = source;
        this.dest = dest;
    }

    @Override
    public boolean equals(Object o) {
        if (o == null || o == this || !(o instanceof Edge)) {
            return o == this;
        }

        Edge<?> edge = (Edge<?>) o;
        return Objects.equals(source, edge.source) &&
               Objects.equals(dest, edge.dest);
    }

    @Override
    public int hashCode() {
        return Objects.hash(source, dest);
    }
}

Und dann die Methoden anpassen:
Java:
    public boolean isConnectedAfterRemoving(Set<Edge<T>> toRemove) {
        Set<T> notVisited = new HashSet<T>(edgesBetweenTwoPoints.entrySet()
            .stream()
            .filter(e -> e.getValue().stream()
                .filter(d -> !toRemove.contains(new Edge<>(e, d)) &&
                             !toRemove.contains(new Edge<>(d, e)))
                .count() > 0)
            .map(Map.Entry::getKey)
            .collect(java.util.stream.Collectors.toSet()));
        if (notVisited.isEmpty())
            return true;
        visit(notVisited.iterator().next(), notVisited, toRemove);
        return notVisited.isEmpty();
    }

    private void visit(T next, Set<T> notVisited, Set<Edge<T>> toRemove) {
        if (!notVisited.remove(next))
          return;
        for (T t : edgesBetweenTwoPoints.get(next))
          if (!toRemove.contains(new Edge<>(next, t)) &&
              !toRemove.contains(new Edge<>(t, next)))
            visit(t, notVisited, toRemove);
    }
Achtung: der Spaß ist ungetestet.
@mihe7 Was bedeutet hier das Object?
Java:
    @Override
    public boolean equals(Object o) {
        if (o == null || o == this || !(o instanceof Edge)) {
            return o == this;
        }

        Edge<?> edge = (Edge<?>) o;
        return Objects.equals(source, edge.source) &&
               Objects.equals(dest, edge.dest);
    }

    @Override
    public int hashCode() {
        return Objects.hash(source, dest);
    }
 

temi

Top Contributor
Was bedeutet hier das Object?

Das ist die Java Klasse Object, von der alle Klassen in Java implizit erben.

Wenn du dir auf der o.g. Seite die Methode equals() anschaust, dann wirst du erkennen, dass deren Signatur ein Object als Parameter fordert. Das ist auch sinnvoll, denn du möchtest ja auch jede Art von Objekt vergleichen können.

Etwas weiter unten findest du auch die Anforderungen, welche die Methode equals() erfüllen sollte.
 
Zuletzt bearbeitet:

Mika34

Bekanntes Mitglied
Oh, ich dachte ich habe die Implementierung nur verrafft. Alles klar :)
Jetzt habe ich aber noch eine Frage. In @mihe7 existiert keine Methode addEdge. Ist diese dann von der vorherigen Imlementierung mittels
Code:
 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);
    }
zu implementieren?
 

Mika34

Bekanntes Mitglied
@mihe7 Es gibt ein Problem. Ich komme momentan bei deiner Modellierung dort nicht weiter.
Wenn ich:
A----B----C----D habe und nun die Kante von B-----C entferne, dann sagt er, das der Graph zusammenhängend ist, aber eigentlich ist er in zwei Teile zerbrochen. Hast du eine Idee, was da falsch läuft?
 
Zuletzt bearbeitet:

mihe7

Top Contributor

Mika34

Bekanntes Mitglied
Mein Code sieht momentan so aus. Jedoch bin ich mir nicht sicher, ob es so in Ordnung geht oder ob ich die addEdge Methode in der EdgeRemover Klasse doch implementieren muss. Könnt ihr mich aufschließen?
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 EdgeRemover<T> {

    private Map<T, List<T>> edgesBetweenTwoPoints = new HashMap<>();

 

    public boolean isConnectedAfterRemoving(Set<Edge<T>> toRemove) {
        Set<T> notVisited = new HashSet<T>(edgesBetweenTwoPoints.entrySet()
            .stream()
            .filter(e -> e.getValue().stream()
                .filter(d -> !toRemove.contains(new Edge<>(e, d)) &&
                             !toRemove.contains(new Edge<>(d, e)))
                .count() > 0)
            .map(Map.Entry::getKey)
            .collect(java.util.stream.Collectors.toSet()));
        if (notVisited.isEmpty())
            return true;
        visit(notVisited.iterator().next(), notVisited, toRemove);
        return notVisited.isEmpty();
    }

    private void visit(T next, Set<T> notVisited, Set<Edge<T>> toRemove) {
        if (!notVisited.remove(next))
          return;
        for (T t : edgesBetweenTwoPoints.get(next))
          if (!toRemove.contains(new Edge<>(next, t)) &&
              !toRemove.contains(new Edge<>(t, next)))
            visit(t, notVisited, toRemove);
    }
}
[B]import[/B] java.util.Objects;





[B]class[/B] Edge<CartesianPoint> {


    [B]private[/B] [B]final[/B] CartesianPoint source;


    [B]private[/B] [B]final[/B] CartesianPoint dest;





    [B]public[/B] Edge(CartesianPoint source, CartesianPoint dest) {


        [B]this[/B].source = source;


        [B]this[/B].dest = dest;


    }





    @Override


    [B]public[/B] [B]boolean[/B] equals(Object o) {


        [B]if[/B] (o == [B]null[/B] || o == [B]this[/B] || !(o [B]instanceof[/B] Edge)) {


            [B]return[/B] o == [B]this[/B];


        }





        Edge<?> edge = (Edge<?>) o;


        [B]return[/B] Objects.[I]equals[/I](source, edge.source) &&


               Objects.[I]equals[/I](dest, edge.dest);


    }





    @Override


    [B]public[/B] [B]int[/B] hashCode() {


        [B]return[/B] Objects.[I]hash[/I](source, dest);


    }


}
 

Mika34

Bekanntes Mitglied
Da die Edge Klasse falsch formatiert wurde, hier die richtig Formatierte
Java:
import java.util.Objects;

class Edge<CartesianPoint> {
    private final CartesianPoint source;
    private final CartesianPoint dest;

    public Edge(CartesianPoint source, CartesianPoint dest) {
        this.source = source;
        this.dest = dest;
    }

    @Override
    public boolean equals(Object o) {
        if (o == null || o == this || !(o instanceof Edge)) {
            return o == this;
        }

        Edge<?> edge = (Edge<?>) o;
        return Objects.equals(source, edge.source) &&
               Objects.equals(dest, edge.dest);
    }

    @Override
    public int hashCode() {
        return Objects.hash(source, dest);
    }
}
 
Ä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
Q Tiefensuche Graph -> Schulprojekt Java Basics - Anfänger-Themen 1
F Graph Tiefensuche Methode Java Basics - Anfänger-Themen 7
S Längster Pfad zwischen zwei Vertices in einem Graph Java Basics - Anfänger-Themen 3
danieldemetry Java - Graph Komponenten - Ausgabe Java Basics - Anfänger-Themen 0
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
D Map<String, Integer> sortieren und der reinfolge nach die Glieder abfragen Java Basics - Anfänger-Themen 3
S nach Import von jars (PLC4x) in Eclipse kann nicht mehr compiliert werden Java Basics - Anfänger-Themen 9
S Java: Wie sortiere ich eine ArrayList benutzerdefinierter Objekte nach einem bestimmten Attribut? Java Basics - Anfänger-Themen 2
M Queue-Datenstruktur: nach dem Elementen entfernen, das Ergebnis ist immer noch nicht optimal. Java Basics - Anfänger-Themen 3
N Hey Leute und zwar versuche ich gerade ein 2D Spiel zu Programmieren aber die Figur will sich nicht nach links oder rechts bewegen :( Java Basics - Anfänger-Themen 12
H Liste nach String-Länge sortieren Java Basics - Anfänger-Themen 1
I Bild richtig speichern / Hochkant im File Explorer, nach Upload vertikal Java Basics - Anfänger-Themen 9
D Wie kann man in Java nach Arrays auf Duplikate prüfen Java Basics - Anfänger-Themen 12
C Probleme mit Byte konvertieren nach int Java Basics - Anfänger-Themen 10
T sortierung der eingabe nach größe Java Basics - Anfänger-Themen 5
G Bei dynamischer Arrayliste nach jeder Auswahl Zahl entfernen Java Basics - Anfänger-Themen 3
ptcho Werte/Position nach dem Funktionsaufruf tauschen? Java Basics - Anfänger-Themen 1
K Warum wird mir hier nach dem ersten Durchlauf zwei mal "welchen Datentyp wollen sie übergeben?" ausgegeben ? Java Basics - Anfänger-Themen 1
H Cast von Float nach String klappt nicht Java Basics - Anfänger-Themen 12
W LocalDate toString und nach Split falsch "erkannt"? Java Basics - Anfänger-Themen 8
B Array nach Elementwerten sortieren? Java Basics - Anfänger-Themen 1
S Größte Zahl nach Eingabe der Zahl 0 ausgeben Java Basics - Anfänger-Themen 6
I Java Mail Timeout erst nach rund 5 Minuten? Java Basics - Anfänger-Themen 9
FireHorses Einen Command erst nach einer Chateingabe aktivieren Java Basics - Anfänger-Themen 1
izoards Sortier Algorithmus für Bounding Box Elememte Links nach Rechts und von Oben nach Unten Java Basics - Anfänger-Themen 33
Jambolo Karten sortieren nach Rang und Farbe Java Basics - Anfänger-Themen 5
Lion.King Subtraktion nach Eingabe im Terminal Java Basics - Anfänger-Themen 7
D Programmieren nach UML Java Basics - Anfänger-Themen 2
rosima26 Java nach letzter Ziffer sortieren Java Basics - Anfänger-Themen 19
H Kompliziertes Sortieren einer ArrayList mit Objekten(Sortieren nach X und Y) Java Basics - Anfänger-Themen 11
H Erste Schritte Nach einer Zahl n soll n Mal der String untereinander ausgegeben werden Java Basics - Anfänger-Themen 3
volcanos List & ArrayList nach Familiennamen abfragen Java Basics - Anfänger-Themen 57
sserio Wie kann man nach einer Klasse fragen? Java Basics - Anfänger-Themen 12
S Java Client-je nach Heap Size Größe startet Applikation oder nicht Java Basics - Anfänger-Themen 4
A String split funktioniert nicht, wenn mehr als 1 Ziffer vor dem Zeichen steht nach dem er trennen soll? Java Basics - Anfänger-Themen 4
F Suche nach betreuender Person für eine Jahresarbeit der 12. Klasse. Java Basics - Anfänger-Themen 6
F nach Methode Programm nicht beenden Java Basics - Anfänger-Themen 9
E Umlaute und Sonderzeichen werden nach der Build Project nicht richtig angezeigt Java Basics - Anfänger-Themen 2
M Bei nach oben scrollen soll Seite aktualisiert werden (Userscript mit Javascript) Java Basics - Anfänger-Themen 10
K log4j nach log4j2 überführen Java Basics - Anfänger-Themen 0
javapingu Jeglichen Inhalt einer Textdatei nach Zeile n löschen Java Basics - Anfänger-Themen 8
J Nach dem Exportieren funktioniert mein Programm nicht mehr Java Basics - Anfänger-Themen 8
P Datei einlesen, nach Begriff filtern und in Datei ausgeben. Problem Standardausgabe über Konsole Java Basics - Anfänger-Themen 19
B Array nach Wert prüfen rekursiv Java Basics - Anfänger-Themen 5
CptK For-Schleife in Thread nach jedem Durchlauf pausieren Java Basics - Anfänger-Themen 35
D Primzahlen Rechner nach Eratostenes von Kyrene Algorithmus Java Basics - Anfänger-Themen 2
rafi072001 Sortieren einer HashMap nach Values Java Basics - Anfänger-Themen 2
L Zahlungen nach Monat filtern Java Basics - Anfänger-Themen 2
J Jtable Eingabe nach Klick ausserhalb der Tabelle übernehmen Java Basics - Anfänger-Themen 6
I String nach Wort suchen Java Basics - Anfänger-Themen 6
C ArrayList sortieren nach bestimmten Buchstaben in den Wörtern Java Basics - Anfänger-Themen 13
javaluke Erste Schritte Array nach Datentyp sortieren Java Basics - Anfänger-Themen 16
D Methoden nach einer bestimmten Reihenfolge ausführen. Java Basics - Anfänger-Themen 20
idontknow707 Matrix nach z.B. Variable durchsuchen Java Basics - Anfänger-Themen 4
O 2D-Array nach einer Spalte sortieren Java Basics - Anfänger-Themen 22
I Liste gruppieren nach Monat? Java Basics - Anfänger-Themen 5
P Ein Objekt nach einem String durchsuchen? Java Basics - Anfänger-Themen 7
M Nach einer erstmaligen Eingabe, eine zweite Eingabe nur noch gegen bestätigung möglich Java Basics - Anfänger-Themen 2
D Input/Output fehlerhafter Algorithmus zum Ersetzen von Array-Werten nach logischem Schema Java Basics - Anfänger-Themen 1
C Meldung einer Klasse nach "oben" Java Basics - Anfänger-Themen 6
B Nach eingefügtem Code erkennt Compiler keine Instanzvar und meldet SyntaxError Java Basics - Anfänger-Themen 2
newcomerJava Nach doppelter Zahl eine Ausgabe Java Basics - Anfänger-Themen 10
M Anzahl Schleifendurchgänge nach x Sekunden anzeigen Java Basics - Anfänger-Themen 2
C Lotto 3, 4, 5, 6 Richtige nach x Ziehungen ermittelt.. Java Basics - Anfänger-Themen 7
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

Ähnliche Java Themen

Neue Themen


Oben