ARRRRRRAYYYYLISTEEENNNNNN

Edge.java

@@ -1,4 +1,4 @@
-public class Edge
+public class Edge implements Comparable
 {
     private Node anfang;
     private Node ende; 
@@ -17,4 +17,10 @@ public class Edge
     public int getWert(){return this.wert;}
     public boolean istGerichtet(){return this.gerichtet;}
     
+    public int compareTo(Object o) {
+        Edge other = (Edge)o;
+        if(this.wert < other.wert)return -1;
+        if(this.wert > other.wert)return 1;
+        return 0;
 }
+}

Graph.java

@@ -108,40 +108,89 @@ public class Graph
                 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();
+        s.bearbeitet = true;
-            else n = e.getAnfang();
+
-            int neu = s.entfernung +e.getWert();
+        while(true){
-            if (n.entfernung==-1 || neu < n.entfernung){
+            Node next = null; 
-                n.entfernung = neu;
+            for (Node n : this.nodes){
-                n.vorgaenger = next;  
+                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;
         }
-        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 z = this.getNode(ziel);
+
-    ArrayList<Node> ergebnis = new ArrayList<Node> ();
+    private boolean istBaum(int start){
-    while (z != null){
+        ArrayList<Node> ergebnis = new ArrayList<Node>();
-        ergebnis.add(z);
+        LinkedList<Node> q = new LinkedList<Node>();
-        z=z.vorgaenger;
+        q.add(this.getNode(start));
+
+        while(!q.isEmpty()){
+            Node aktuell = q.removeFirst();
+            if (ergebnis.contains(aktuell)){
+                return false;
+            }
+
+            ArrayList<Node> erreichbar = aktuell.getTargets();
+            Collections.sort(erreichbar);
+            q.addAll(erreichbar);
+
+            ergebnis.add(aktuell);
+        }
+        return true;
+    }
+
+    public Graph prim(){
+        Graph sb = new Graph(); 
+        for (Node n: this.nodes){
+            sb.addNode(n.getNumber());
+        }
+
+        ArrayList<Edge> available = new ArrayList<Edge>();
+        ArrayList<Node> done = new ArrayList<Node>();
+        ArrayList<Edge> added = new ArrayList<Edge>();
+        done.add(this.getNode(1));
+        while(true){
+            for (int i = 0; i < done.size(); i++){
+                Node n = done.get(i);
+                for (Edge e : n.getEdges()){
+                    if (!done.contains(e.getEnde())||!added.contains(e))available.add(e);
+                }
+                Collections.sort(available);
+            }
+            if(available.isEmpty())break;
+            Edge p = available.get(0);
+            ArrayList<Node> erreichbar = sb.tiefensuche(1);
+            sb.addEdge(p);
+            added.add(p);
+            done.add(p.getEnde());
+        }
+        return sb;
     }
-    return ergebnis;
-}
 }

Node.java

@@ -38,10 +38,10 @@ public class Node implements Comparable
         ArrayList<Edge> t= new ArrayList<Edge>();
         for (Edge e : this.edges){
             if(e.getAnfang()== this){
-                edges.add(e);
+                t.add(e);
             }
             else if (!e.istGerichtet()){
-                edges.add(e);
+                t.add(e);
             }
         }
         return t;

test.java

@@ -68,7 +68,7 @@ public static void test2(){
     g.addEdge(4,2,5,false);
     g.addEdge(2,9,2,false);
     g.addEdge(9,8,4,false);
-    ArrayList<Node
+    g.prim();
     
 }
 }