# I would like to learn how to implement a greedy Dijkstra algoritm in java

I already have a working program that tests a breath first search traversal, I just not sure how to go about implement a Dijkstra greedy algorithm......... here's my code:

import java.util.*;
import java.io.*;
public class Graph {
private int numVertices;
private int numEdges;

public Graph(int n) {
numVertices = n;
numEdges = 0;
//  adjMatrix = new int[n][];
adjList = new Vector<TreeMap<Integer,Integer>>();
for (int i=0; i<numVertices; i++) {
}
}

public int getNumVertices() {
return numVertices;
}

public int getNumEdges() {
return numEdges;
}

public int getEdgeWeight(Integer v, Integer w) {
}

public void addEdge (Integer v, Integer w, int wgt) {
numEdges++;
}

public void addEdge(Edge e) {
Integer v = e.getV();
Integer w = e.getW();
int weight = e.getWeight();
}

public void removeEdge(Edge e) {
Integer v = e.getV();
Integer w = e.getW();
numEdges--;
}

public Edge findEdge(Integer v,Integer w) {
int wgt = adjList.get(v).get(w);
return new Edge(v,w,wgt);
}

TreeMap<Integer,Integer> getAdjList(Integer v) {
}

}

class Edge<E> {
private Integer v, w;
private int weight;

public Edge (Integer first, Integer second, int edgeWeight) {
v = first;
w = second;
weight = edgeWeight;
}

public int getWeight() {
return weight;
}

public Integer getV() {
return v;
}

public Integer getW() {
return w;
}
}

class iterator implements Iterator<Integer> {
private Graph g;
private int numVertices;
private int count;
private int[] mark;
private int iter;

public iterator(Graph g) {
this.g = g;
numVertices = g.getNumVertices();
mark = new int[numVertices];
Arrays.fill(mark,0,numVertices,-1);
count = 0;
iter = -1;
startSearch();
}

public boolean hasNext() {
return (iter >= 0) && (iter < numVertices);
}

public Integer next() throws NoSuchElementException {
if (hasNext()) {
return mark[iter++];
}
else {
throw new NoSuchElementException();
}
}

public void remove() {
throw new UnsupportedOperationException();
}

protected void startSearch() {
for (int v=0; v<numVertices; v++) {
if (mark[v] == -1) {
//System.out.println(mark[v]);
search(v);
}
}
iter = 0;
}

protected void search(Integer vertex) {
TreeMap<Integer,Integer> m;
Set<Integer> connectedVertices;
Integer v;
while (!q.isEmpty()) {
System.out.println(q);
v = q.remove();
if (mark[v] == -1) {
mark[v] = count++;
connectedVertices = m.keySet();
//System.out.println(connectedVertices);
for (Integer w : connectedVertices) {
if (mark[w] ==-1) {
}
}
}
}
}
}

class Tester {
public static void main (String args[]) {
Graph g = new Graph(6);
iterator irt = new iterator(g);
irt.startSearch();
}
}
###### Who is Participating?

Commented:
0
Question has a verified solution.

Are you are experiencing a similar issue? Get a personalized answer when you ask a related question.

Have a better answer? Share it in a comment.