fehler beim Kimmig

Graph.java

@@ -1,4 +1,6 @@
 import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Collections;
 public class Graph
 {
     private ArrayList<Node> nodes;
@@ -12,16 +14,17 @@ public class Graph
     public void addNode(Node n) {
         this.nodes.add(n);
     }
-    
+
     public void addNode(int nr){
         this.nodes.add(new Node(nr));
     }
-    
+
     public void addEdge(Edge e){
         this.edges.add(e);
         e.getAnfang().addEdge(e);
         e.getEnde().addEdge(e);
     }
+
     public void addEdge(int a, int e, int w, boolean g){
         Node an = null;
         Node en = null;
@@ -38,7 +41,7 @@ public class Graph
         }
         this.addEdge(new Edge(an, en, w, g));
     }
-    
+
     public Node getNode(int nr){
         for (Node n : this.nodes){
             if (n.getNumber() == nr){
@@ -47,4 +50,98 @@ public class Graph
         }
         return null;
     }
+
+    public ArrayList<Node> breitensuche(int start){
+        ArrayList<Node> ergebnis = new ArrayList<Node>();
+        LinkedList<Node> q = new LinkedList<Node>();
+        q.add(this.getNode(start));
+
+        while(!q.isEmpty()){
+            Node aktuell = q.removeFirst();
+            if (ergebnis.contains(aktuell)){
+                continue;
+            }
+
+            ArrayList<Node> erreichbar = aktuell.getTargets();
+            Collections.sort(erreichbar);
+            q.addAll(erreichbar);
+
+            ergebnis.add(aktuell);
+        }
+
+        return ergebnis;
+    }
+
+    public ArrayList<Node> tiefensuche(int start){
+        ArrayList<Node> ergebnis = new ArrayList<Node>();
+        LinkedList<Node> q = new LinkedList<Node>();
+        q.add(this.getNode(start));
+
+        while(!q.isEmpty()){
+            Node aktuell = q.removeLast();
+            if (ergebnis.contains(aktuell)){
+                continue;
+            }
+
+            ArrayList<Node> erreichbar = aktuell.getTargets();
+            Collections.sort(erreichbar, Collections.reverseOrder());
+            q.addAll(erreichbar);
+
+            ergebnis.add(aktuell);
+        }
+
+        return ergebnis;
+    }
+
+    public ArrayList<Node> dijkstra (int start, int ziel){
+        Node s = this.getNode(start);
+        s.entfernung=0;
+        ArrayList<Edge> edges = s.getEdges();
+        for (Edge e : edges){
+            Node n;
+
+            if (e.getAnfang() == s ) n= e.getEnde();
+            else n = e.getAnfang();
+            int neu = s.entfernung +e.getWert();
+            if (n.entfernung==-1 || neu < n.entfernung){
+                n.entfernung = neu;
+                n.vorgaenger = s;  
+            }
+        }
+        
+        s.bearbeitet = true;
+        
+        while(true){
+        Node next = null; 
+        for (Node n : this.nodes){
+            if (!n.bearbeitet) continue;
+            if (n.entfernung == -1) continue; 
+            
+            if (next == null || next.entfernung > n.entfernung){
+                next = n;
+            }
+        }
+        if (next == null) break;
+        edges = next.getEdges();
+        for (Edge e : edges){
+            Node n;
+
+            if (e.getAnfang() == s ) n= e.getEnde();
+            else n = e.getAnfang();
+            int neu = s.entfernung +e.getWert();
+            if (n.entfernung==-1 || neu < n.entfernung){
+                n.entfernung = neu;
+                n.vorgaenger = next;  
+            }
+        }
+        next.bearbeitet = true;
+    }
+    Node z = this.getNode(ziel);
+    ArrayList<Node> ergebnis = new ArrayList<Node> ();
+    while (z != null){
+        ergebnis.add(z);
+        z=z.vorgaenger;
+    }
+    return ergebnis;
+}
 }

Node.java

@@ -1,11 +1,18 @@
 import java.util.ArrayList;
-public class Node
+public class Node implements Comparable
 {
     private int number;
     private ArrayList<Edge> edges;
+    public int entfernung;
+    public Node vorgaenger;
+    public boolean bearbeitet;
+    
     public Node(int n){
         this.number = n;
         this.edges = new ArrayList<Edge>(); 
+        
+        entfernung = -1;
+        vorgaenger = null;
     }
     
     public int getNumber (){return this.number;}
@@ -26,4 +33,23 @@ public class Node
         }
         return t;
     }
+    
+    public ArrayList<Edge> getEdges(){
+        ArrayList<Edge> t= new ArrayList<Edge>();
+        for (Edge e : this.edges){
+            if(e.getAnfang()== this){
+                edges.add(e);
+            }
+            else if (!e.istGerichtet()){
+                edges.add(e);
+            }
+        }
+        return t;
+    }
+    public int compareTo(Object o) {
+        Node other = (Node)o;
+        if(this.number < other.number)return -1;
+        if(this.number > other.number)return 1;
+        return 0;
+    }
 }

test.java

@@ -1,4 +1,5 @@
 import java.util.ArrayList;
+import java.util.Collections;
 public class test
 {
     public static void test(){
@@ -38,9 +39,36 @@ public class test
     
     Node n = g.getNode(16);
     ArrayList<Node> targets = n.getTargets(); 
-    for (Node target : targets){
+    Collections.sort(targets);
+    /*for (Node target : targets){
         System.out.println(target.getNumber());
     }
+    ArrayList<Node> b = g.breitensuche(1);
+    for (Node t: b){
+        System.out.println(t.getNumber());
+    }*/
+    ArrayList<Node> t = g.tiefensuche(21);
+    for (Node r: t){
+        System.out.println(r.getNumber());
+    }
+}
+public static void test2(){
+    Graph g = new Graph();
+    for(int i = 1; i <= 9 ; i++){
+        g.addNode(i);
+    }
+    g.addEdge(1,6,4,false);
+    g.addEdge(6,7,2,false);
+    g.addEdge(1,3,3,false);
+    g.addEdge(6,5,4,false);
+    g.addEdge(7,9,1,false);
+    g.addEdge(5,4,2,false);
+    g.addEdge(5,2,3,false);
+    g.addEdge(3,4,6,false);
+    g.addEdge(4,2,5,false);
+    g.addEdge(2,9,2,false);
+    g.addEdge(9,8,4,false);
+    ArrayList<Node
     
 }
 }