Разделение GUI и алгоритма

Author: Akibardin

src/main/java/ru/etu/practice/Edge.java

@@ -3,7 +3,7 @@
 public class Edge {
     @Override
     public String toString() {
-        return "Edge " + " " + from + "—" + to + " " + distance + '\n';
+        return "Edge " + " " + from + "—" + to + " " + distance;
     }
 
     /**

src/main/java/ru/etu/practice/Graph.java

@@ -3,25 +3,55 @@
 import java.util.*;
 
 public class Graph {
-    private static final int SIZE = 26;
+//    private static final int SIZE = 26;
 
     private List<Edge> inputEdges;
-    private Set<Node> inputVertices;
+    private List<Node> inputVertices;
+    public boolean isModified = false;
+
+//    public
 
     public List<Edge> getInputEdges() {
         return inputEdges;
     }
 
-    public Set<Node> getInputVertices() {
+    public List<Node> getInputVertices() {
         return inputVertices;
     }
 
     public Graph() {
+        this.inputEdges = new LinkedList<>();
+        this.inputVertices = new LinkedList<>();
+    }
+
+//    public void initGraph(List<Edge> inputEdges, List<Node> inputVertices) {
+//        this.inputEdges = new LinkedList<>(inputEdges);
+//        this.inputVertices = new LinkedList<>(inputVertices);
+//    }
+
+    public void addEdge(Node from, Node to, int distance) {
+        Edge newEdge = new Edge(from, to, distance);
+        for (Edge edge : inputEdges)
+            if (edge.equalsWay(newEdge))
+                return;
+        inputEdges.add(newEdge);
+        isModified = true;
+    }
+
+    public void addVertex(Node node) {
+        if (!inputVertices.contains(node))
+            inputVertices.add(node);
+        isModified = true;
+    }
 
+    public void addVertex() {
+        int len = inputVertices.size();
+        inputVertices.add(new Node((char)('a' + len)));
     }
 
-    public void initGraph(List<Edge> inputEdges, List<Node> inputVertices) {
-        this.inputEdges = new LinkedList<>(inputEdges);
-        this.inputVertices = new HashSet<>(inputVertices);
+    public void clear() {
+        inputVertices.clear();
+        inputEdges.clear();
+        isModified = false;
     }
 }

src/main/java/ru/etu/practice/Kruskal.java

@@ -5,28 +5,30 @@
 public class Kruskal {
 
     private final Graph graph;
-    private int i = -1;
-    private int value = 0;
+    private int stepID = -1;
+    private int weight = 0;
 
     public List<Edge> getInputEdges() {
         return inputEdges;
     }
 
-    private final List<Edge> inputEdges;
+    private List<Edge> inputEdges;
     private final List<Node> inputVertices;
     private final List<Edge> outputEdges;
     private final List<Set<Node>> outputVertices;
 
+    public boolean isStarted = false;
 
-    public Kruskal(Graph graph){
-        this.graph = graph;
+    public Kruskal() {
+        this.graph = new Graph();
         inputEdges = new LinkedList<>(graph.getInputEdges());
-        inputVertices = new LinkedList<>(graph.getInputVertices());
+        inputVertices = graph.getInputVertices();
         outputEdges = new LinkedList<>();
         outputVertices = new LinkedList<>();
     }
 
     public void sortEdges() {
+        inputEdges = new LinkedList<>(graph.getInputEdges());
         inputEdges.sort(new Comparator<Edge>() {
             @Override
             public int compare(Edge edge1, Edge edge2) {
@@ -41,6 +43,14 @@ public List<Edge> getOutputEdges() {
         return outputEdges;
     }
 
+    public List<Node> getInputVertices() {
+        return inputVertices;
+    }
+
+    public Graph getGraph() {
+        return graph;
+    }
+
     /**
      * tuple.get(0) instanceof State -- return state
      * tuple.get(1) instanceof Edge -- added edge
@@ -49,32 +59,39 @@ public List<Edge> getOutputEdges() {
      */
     public List<Object> nextStep() {
         List<Object> tuple = new LinkedList<>();
-        if (i == -1) {
+        if (stepID == -1 || !isStarted) {
+            isStarted = true;
+            graph.isModified = false;
             sortEdges();
-            i++;
+            stepID++;
             tuple.add(State.SORT);
             return tuple;
         }
-        if (i >= inputEdges.size()) {
+
+        if (stepID >= inputEdges.size() || graph.isModified) {
+            isStarted = false;
             tuple.add(State.END);
-            tuple.add(value);
-            i = -1;
+            tuple.add(weight);
+            stepID = -1;
+            graph.isModified = true;
             return tuple;
         }
 
-        Edge edge = inputEdges.get(i++);
-        value += edge.distance;
+        Edge edge = inputEdges.get(stepID++);
+        weight += edge.distance;
         Set<Node> tempVertexes = new HashSet<>();
         Node vertex1 = edge.from;
         Node vertex2 = edge.to;
         tempVertexes.add(vertex1);
         tempVertexes.add(vertex2);
 
         if (outputVertices.size() > 0) {
-            if (outputVertices.get(0).size() == inputEdges.size()) {
+            if (outputVertices.get(0).size() == inputVertices.size()) {
                 tuple.add(State.END);
-                value -= edge.distance;
-                tuple.add(value);
+                weight -= edge.distance;
+                tuple.add(weight);
+                stepID = -1;
+                graph.isModified = true;
                 return tuple;
             }
         }
@@ -84,7 +101,7 @@ public List<Object> nextStep() {
             if (isOld(currently, tempVertexes)) {
                 tuple.add(State.LOOP);
                 tuple.add(edge);
-                value -= edge.distance;
+                weight -= edge.distance;
                 return tuple;
             }
             if (isCommon(currently, tempVertexes)) {
@@ -118,13 +135,14 @@ public List<Object> nextStep() {
     }
 
     public String kruskal() {
-        i = -1;
+        stepID = -1;
         StringBuilder result = new StringBuilder();
         while (true) {
             List<Object> tuple = nextStep();
             result.append(addStepInfo(tuple));
-            System.err.println(tuple.get(0));
+            //System.err.println(tuple.get(0));
             if (tuple.get(0) == State.END) {
+                graph.isModified = true;
                 break;
             }
         }
@@ -179,7 +197,14 @@ private boolean isOld(Set<Node> first, Set<Node> second) {
     public void clearOutput() {
         outputEdges.clear();
         outputVertices.clear();
-        i = -1;
-        value = 0;
+        stepID = -1;
+        weight = 0;
+    }
+
+    public void clear() {
+        clearOutput();
+        inputVertices.clear();
+        inputEdges.clear();
+        graph.clear();
     }
 }