Question

In the class GraphAlgorithm, insert java code for the method prim

public class MyGraph {

public static final int MAXSIZE = 100;

public static final double BIGM = 10000000;

public MyGraph(int size) {

n = size;

nodeStart = new Edge[MAXSIZE];

for (int i=0; i<n; i++) {

nodeStart[i] = null;

}

}

public int getSize() {

return n;

}

public double getCost(int i, int j) {

double value = BIGM;

Edge e = nodeStart[i];

while (e !=null) {

if (e.dest == j) value = e.cost;

e=e.next;

}

return value;

}

public void setCost(int i, int j, double c) {

Edge e = nodeStart[i];

boolean found = false;

while (e !=null && !found) {

if (e.dest == j) {

e.cost = c;

found = true;

}

else e=e.next;

}

if (!found) insertEdge(i,j,c);

}

public void insertEdge(int i, int j, double c) {

deleteEdge(i,j);

Edge ins = new Edge(i,j,c);

ins.next = nodeStart[i];

nodeStart[i] = ins;

}

public void deleteEdge(int i, int j) {

boolean found = false;

Edge prev = null;

Edge e = nodeStart[i];

if (e != null) {

if (e.dest == j) {

found = true;

nodeStart[i] = e.next;

}

else {

prev = e;

e = e.next;

}

}

while (e != null && !found) {

if (e.dest == j) {

found = true;

prev.next = e.next;

}

else {

prev = e;

e = e.next;

}

}

}

public MyGraph copy() {

MyGraph result = new MyGraph(n);

Edge e = first();

while (!this.eol()) {

result.insertEdge(e.orig, e.dest, e.cost);

e = next();

}

return result;

}

public Edge first() {

int currNode = 0;

currentLoc = nodeStart[currNode];

while (currentLoc == null && currNode < n-1) {

currentLoc = nodeStart[++currNode];

}

return currentLoc;

}

public boolean eol() {

return (currentLoc == null);

}

public Edge next() {

if (!eol()) {

int currNode = currentLoc.orig;

currentLoc = currentLoc.next;

while (currentLoc == null && currNode < n-1) {

currNode++;

currentLoc = nodeStart[currNode];

}

return currentLoc;

}

else return null;

}

private int n;

private Edge[] nodeStart;

private Edge currentLoc;

}

public class Edge { public Edge(int i, int j, double c) orig-i; dest-ji cost Ci public int orig; public int dest; public double cost; public Edge next - null;

Answer 1

As the required functionality for method prim was not specified hence as per my understadning I have added definition wherein Graph has to be copied using the copy method and returned.

public class Edge {
    public int orig, dest;
    public double cost;
    public Edge next=null;
    public Edge(int i, int j, double c) {
        orig = i;
        dest = j;
        cost = c;
    }
}

public class GraphAlgorithm {
    public static double totalCost(MyGraph G) {
        double total = 0;
        Edge loc = G.first();
        while (!G.eol()) {
            total = total + loc.cost;
            loc = G.next();
        }
        return total;
    }

    public static void displayGraph(MyGraph G) {
        Edge loc = G.first();
        while (!G.eol()) {
            System.out.println(loc.orig + " " + loc.dest + " " + loc.cost);
            loc = G.next();
        }
    }

    //Added prim method for copying Graph G to H and returning the same
    public static MyGraph prim(MyGraph G) {
    MyGraph H = G.copy();
    return H; }

    public static MyGraph dijkstra(MyGraph G, int source, int terminal) {
        int n = G.getSize();
        MyGraph result = new MyGraph(n);
        double[] label = new double[n];
        label[source] = 0;
        int[] pred = new int[n];
        pred[source] = source;
        for (int i = 0; i < n; i++)
            if (i != source) pred[i] = -1;
            for (int step = 1; step < n; step++) {
                Edge best = null;
                double min = MyGraph.BIGM;
                Edge e = G.first();
                while (!G.eol()) {
                    if (pred[e.orig] >= 0 && pred[e.dest] < 0 && label[e.orig] + e.cost < min) {
                        best = e;
                        min = label[e.orig] + e.cost;
                    }
                    e = G.next();
                }

                pred[best.dest] = best.orig;

                label[best.dest] = label[best.orig] + best.cost;

            }
            int node = terminal;
            while (node != pred[node]) {
                result.insertEdge(pred[node], node, G.getCost(pred[node], node));
                node = pred[node];
            }

        return result;
    }
}

package Abc_28;
public class MyGraph {
    public static final int MAXSIZE = 100;
    public static final double BIGM = 10000000;
    public MyGraph(int size) {
        n = size;
        nodeStart = new Edge[MAXSIZE];
        for (int i=0; i<n; i++) {
            nodeStart[i] = null;
        }
    }
    public int getSize() {
        return n;
    }
    public double getCost(int i, int j) {
        double value = BIGM;
        Edge e = nodeStart[i];
        while (e !=null) {
            if (e.dest == j) value = e.cost;
            e=e.next;
        }
        return value;
    }
    public void setCost(int i, int j, double c) {
        Edge e = nodeStart[i];
        boolean found = false;
        while (e !=null && !found) {
            if (e.dest == j) {
                e.cost = c;
                found = true;
            }
            else e=e.next;
        }
        if (!found) insertEdge(i,j,c);
    }
    public void insertEdge(int i, int j, double c) {
        deleteEdge(i,j);
        Edge ins = new Edge(i,j,c);
        ins.next = nodeStart[i];
        nodeStart[i] = ins;
    }
    public void deleteEdge(int i, int j) {
        boolean found = false;
        Edge prev = null;
        Edge e = nodeStart[i];
        if (e != null) {
            if (e.dest == j) {
                found = true;
                nodeStart[i] = e.next;
            }
            else {
                prev = e;
                e = e.next;
            }
        }
        while (e != null && !found) {
            if (e.dest == j) {
                found = true;
                prev.next = e.next;
            }
            else {
                prev = e;
                e = e.next;
            }
        }
    }
    public MyGraph copy() {
        MyGraph result = new MyGraph(n);
        Edge e = first();
        while (!this.eol()) {
            result.insertEdge(e.orig, e.dest, e.cost);
            e = next();
        }
        return result;
    }
    public Edge first() {
        int currNode = 0;
        currentLoc = nodeStart[currNode];
        while (currentLoc == null && currNode < n-1) {
            currentLoc = nodeStart[++currNode];
        }
        return currentLoc;
    }
    public boolean eol() {
        return (currentLoc == null);
    }
    public Edge next() {
        if (!eol()) {
            int currNode = currentLoc.orig;
            currentLoc = currentLoc.next;
            while (currentLoc == null && currNode < n-1) {
                currNode++;
                currentLoc = nodeStart[currNode];
            }
            return currentLoc;
        }
        else return null;
    }
    private int n;
    private Edge[] nodeStart;
    private Edge currentLoc;
}

public class MSTmain {
    public static void main(String[] args) {
        MyGraph G = new MyGraph(6);
        G.insertEdge(0,2,5);
        G.insertEdge(2,0,5);
        G.insertEdge(1,0,1);
        G.insertEdge(0,1,1);
        G.insertEdge(0,5,8);
        G.insertEdge(5,0,8);
        G.insertEdge(1,2,7);

        G.insertEdge(2,1,7);
        G.insertEdge(1,3,5);
        G.insertEdge(3,1,5);
        G.insertEdge(2,3,1);
        G.insertEdge(3,2,1);
        G.insertEdge(1,5,9);
        G.insertEdge(5,1,9);

        G.insertEdge(3,4,3);
        G.insertEdge(4,3,3);
        G.insertEdge(4,2,7);
        G.insertEdge(2,4,7);
        G.insertEdge(5,2,3);
        G.insertEdge(2,5,3);
        G.insertEdge(4,5,1);
        G.insertEdge(5,4,1);
        GraphAlgorithm.displayGraph(G);
        System.out.println();
        MyGraph H = GraphAlgorithm.prim(G);
        GraphAlgorithm.displayGraph(H);
        System.out.println(GraphAlgorithm.totalCost(H));
        System.out.println();
        MyGraph I = GraphAlgorithm.dijkstra(G,0,4);
        GraphAlgorithm.displayGraph(I);
        System.out.println(GraphAlgorithm.totalCost(I));
        System.out.println();

    }
}