Endlich funktionierts richtig

Projektgruppe_175/src/base/Graph.java

@@ -103,7 +103,7 @@ public class Graph<T> {
     public List<Edge<T>> getEdges(Node<T> node) {
 
     	return edges.stream()
-    			.filter(x -> x.getNodeA().equals(node) || x.getNodeB().equals(node))
+    			.filter(x -> x.contains(node))
     			.collect(Collectors.toList());
         
     }
@@ -118,8 +118,7 @@ public class Graph<T> {
     public Edge<T> getEdge(Node<T> nodeA, Node<T> nodeB) {
 
     	return edges.stream()
-    			.filter(x -> x.getNodeA().equals(nodeA) && x.getNodeB().equals(nodeB) ||
+    			.filter(x -> x.contains(nodeA) && x.contains(nodeB))
-    					     x.getNodeA().equals(nodeB) && x.getNodeB().equals(nodeA))
     			.findFirst()
     			.orElse(null);
     }

Projektgruppe_175/src/base/GraphAlgorithm.java

@@ -81,17 +81,30 @@ public abstract class GraphAlgorithm<T> {
 		Iterator<Node<T>> iter = availableNodes.iterator();
 		Iterator<Node<T>> minElemIter = availableNodes.iterator();
 		
-		Node<T> minNode;
+		Node<T> minNode = null;
-		AlgorithmNode<T> minAlgoNode;
+		AlgorithmNode<T> minAlgoNode = null;
 		Node<T> tempNode;
 		AlgorithmNode<T> tempAlgoNode;
 		
-		if (iter.hasNext()) {
+		/////
 		
-			// Set minimum to first element
+		/*
-			minNode = iter.next();
+		
-			minAlgoNode = algorithmNodes.get(minNode);
+		minNode = availableNodes.stream().min((x, y) -> Double.compare(algorithmNodes.get(x).value, algorithmNodes.get(y).value)).orElse(null);
-			minElemIter.next();
+		
+		if (minNode != null)
+			System.out.println(availableNodes.remove(minNode));
+		
+		if (minNode == null)
+			return null;
+		else
+			return algorithmNodes.get(minNode);
+		
+		*/
+		
+		/////
+				
+		if (iter.hasNext()) {
 						
 			while (iter.hasNext()) {
 				
@@ -100,13 +113,12 @@ public abstract class GraphAlgorithm<T> {
 				
 				if (DEBUG_2) {
 					System.out.println("gSN with size " + availableNodes.size() + " and n=" + n);
-					System.out.flush();
 				}
 				
 				tempNode = iter.next();
 				tempAlgoNode = algorithmNodes.get(tempNode);
-				if (tempAlgoNode.value > 0) {
+				if (tempAlgoNode.value >= 0) {
-					if (tempAlgoNode.value < minAlgoNode.value) {
+					if (minAlgoNode == null || tempAlgoNode.value < minAlgoNode.value) {
 												
 						// New minimum
 						minNode = tempNode;
@@ -119,12 +131,22 @@ public abstract class GraphAlgorithm<T> {
 
 			}
 			minElemIter.remove();
+			//availableNodes.remove(minNode);
+			
+			if (DEBUG_2)
+				if (minNode != null)
+					System.out.println("Exit gSN with sN="+minNode.getValue());
+				else
+					System.out.println("Exit gSN with sN=null");
 			
 			return minAlgoNode;
 			
 		}
 
 		return null;
+		
+		
+		
 	}
 
 	/**
@@ -149,6 +171,10 @@ public abstract class GraphAlgorithm<T> {
 		if (DEBUG_2)
 			System.out.println("Enter run");
 			
+		if (DEBUG_2) {
+			
+		}
+		
 		AlgorithmNode<T> v = getSmallestNode();
 		
 		while (v != null) {
@@ -177,7 +203,7 @@ public abstract class GraphAlgorithm<T> {
 						n.value = a;
 						n.previous = v;
 												
-						System.out.println("--" + n + " " + n.previous);
+						System.out.println("--" + n.node.getValue() + " " + n.previous.node.getValue());
 						
 					}
 					
@@ -213,18 +239,26 @@ public abstract class GraphAlgorithm<T> {
 		if (prevNode == null)
 			return null;
 		
+		//int x = 0;
+		
 		while (!(prevNode.value == 0)) {
 			
+			//if (x > 1000)
+				//return null;
+			
+			//x++;
+			
 			if (DEBUG_2)
 				System.out.println("Iteration");
 			
 			AlgorithmNode<T> prevPrevNode = prevNode.previous;
 						
-			if (prevNode.equals(prevPrevNode)) throw new IndexOutOfBoundsException();
-			
 			if (prevPrevNode == null)
 				return null;
 			
+			if (DEBUG_2)
+				System.out.println("==" + prevNode.node.getValue() + " " + prevPrevNode.node.getValue());
+			
 			reversePath.add(new Edge<T>(prevPrevNode.node, prevNode.node));
 			prevNode = prevPrevNode;
 			

Projektgruppe_175/src/tests/student/GraphAlgoComplexityTest.java

@@ -17,6 +17,8 @@ public class GraphAlgoComplexityTest {
 		
 		for (int i = 30; i < 50; i+=1) {
 			
+			/*
+			
 			Graph<Integer> g = generateGraph(i);
 			DumbGraphAlgorithm ga = new DumbGraphAlgorithm(g, g.getNodes().get(0));
 			
@@ -28,6 +30,8 @@ public class GraphAlgoComplexityTest {
 			
 			System.out.println(i + "," + ga.getN() + "," + divN + "," + divN2 + "," + divN3);
 			
+			*/
+			
 			/////////////
 			
 			Graph<Integer> g2 = generateGraph2(i);
@@ -35,7 +39,7 @@ public class GraphAlgoComplexityTest {
 			
 			ga2.run();
 			
-			List<Edge<Integer>> path = ga2.getPath(g2.getNodes().get(12));
+			List<Edge<Integer>> path = ga2.getPath(g2.getNodes().get(2));
 			for (Edge<Integer> edge : path) {
 				System.out.println(edge.getNodeA().getValue().toString() + " " + edge.getNodeB().getValue().toString());
 			}
@@ -79,6 +83,8 @@ public class GraphAlgoComplexityTest {
 			g.addEdge(nodes.get(i), nodes.get(i+1));
 		}
 		
+		g.addEdge(nodes.get(6), nodes.get(9));
+		
 		return g;
 		
 	}

doc/Dokumentation.tex

@@ -250,14 +250,27 @@ Schritten $M^h$ die Längen von den Pfaden enthält,
 die am kürzesten sind und dabei nicht mehr als
 $h + 1$ Kanten besuchen.
 
-%Für die Graphmatrix $M$ gilt außerdem
+Sei also $x$ die Länge des Zykels. Es gilt: $x < 0$.
-%$M(k_1, k_2) < 0$ usw. bis $M(k_n, k_1) < 0$.
+Daraus folgt, dass $2 \cdot x < x$ und $3 \cdot x < x$ usw.
+Bei beliebig großen $n$ gibt es also die Gefahr,
+dass der Algorithmus versucht, so oft wie möglich
+diesen Zyklus zu durchlaufen, um die kleinste Länge
+zu erreichen.
 
 \subsubsection{Teil (b)}
 
-Best case: $\Theta()$
+Best case: In diesem Fall müsste der Algorithmus
 
-Worst case: $\Theta()$
+$$\Theta()$$
+
+Worst case: Im schlimmsten Fall müsste der Algorithmus
+in jeder Iteration der Schleife die Länge von jedem
+Knoten zu jedem anderen Knoten berechnen. Es müssten
+also alle Felder der $(n \times n)$-Matrix neu berechnet
+werden. Deswegen müssten jede Iteration $n^2$ Schritte
+durchgeführt werden. Das resultiert in der Asymptotik
+
+$$\Theta(n^3)$$
 
 \section{Weitergestaltung des Spiels}