using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace RGR

{

public class Edge<W, D> : ICloneable

{

private int vertex1;

private int vertex2;

private W weight;

private D data;

public Edge()

{

vertex1 = -1;

vertex2 = -1;

}

public Edge(int v1, int v2)

{

vertex1 = v1;

vertex2 = v2;

}

public Edge(int v1, int v2, W w)

{

vertex1 = v1;

vertex2 = v2;

weight = w;

}

public Edge(int v1, int v2, W w, D d)

{

vertex1 = v1;

vertex2 = v2;

weight = w;

data = d;

}

public Object Clone()

{

return new Edge<W, D>(Vertex1, Vertex2, Weight, Data);

}

public int Vertex1

{

set

{

vertex1 = value;

}

get

{

return vertex1;

}

}

public int Vertex2

{

set

{

vertex2 = value;

}

get

{

return vertex2;

}

}

public W Weight

{

set

{

weight =value;

}

get

{

return weight;

}

}

public D Data

{

set

{

data = value;

}

get

{

return data;

}

}

}

}

Graph.cs

using System;

{

public abstract class Graph<W, D>

{

public static int MAXVERTICESCOUNT = 10;

private int verticesCount;

private int edgesCount;

private bool directed;

public SortedDictionary<int, int> dictionary;

public Graph()

{

verticesCount = 0;

edgesCount = 0;

directed = false;

}

public Graph(int cVertex, bool cDirected)

{

verticesCount = cVertex;

edgesCount = 0;

directed = cDirected;

}

public Graph(int cVertex, int cEdge, bool cDirected)

{

verticesCount = cVertex;

edgesCount = cEdge;

directed = cDirected;

}

public int getVerticesCount()

{

return verticesCount;

}

public void increaseVerticesCount()

{

verticesCount++;

}

public void decreaseVerticesCount()

{

verticesCount--;

}

public int getEdgesCount()

{

return edgesCount;

}

public void increaseEdgesCount()

{

edgesCount++;

}

public void decreaseEdgesCount()

{

edgesCount--;

}

public void decreaseEdgesCount(int decrease)

{

edgesCount -= decrease;

}

public bool isDirected()

{

return directed;

}

abstract public bool getType();

public double denseCoef()

{

if (directed) return (double)edgesCount / ((double)verticesCount * ((double)verticesCount - 1.0));

return 2.0 * (double)edgesCount / ((double)verticesCount * ((double)verticesCount - 1.0));

}

abstract public Graph<W, D> toListGraph();

abstract public Graph<W, D> toMatrixGraph();

abstract public bool addVertex(int vertexNumber);

abstract public bool removeVertex(int vertexNumber);

abstract public bool addEdge(int vertex1, int vertex2);

abstract public bool addEdge(Edge<W, D> edge);

abstract public bool removeEdge(int vertex1, int vertex2);

abstract public bool hasEdge(int vertex1, int vertex2);

abstract public W getEdgeWeight(int vertex1, int vertex2);

abstract public bool setEdgeWeight(int vertex1, int vertex2, W weight);

abstract public D getEdgeData(int vertex1, int vertex2);

abstract public bool setEdgeData(int vertex1, int vertex2, D data);

abstract public List<int> getNeighbors(int vertexNumber);

//---PARENT ITERATORS--------------------------------

public abstract class Iterator<W, D>

{

public Graph<W, D> graph;

public Edge<W, D> currentPosition;

public Iterator(Graph<W, D> graphC)

{

graph = graphC;

begin();

}

public abstract void begin();

public abstract void end();

public abstract void next();

public abstract Edge<W, D> state();

}

}

}

LGraph.cs

using System;

{

class LGraph<W, D> : Graph<W, D>, ICloneable

{

private List<List<Edge<W, D>>> adjacencyList;

public LGraph()

: base()

{

adjacencyList = new List<List<Edge<W, D>>>();

dictionary = new SortedDictionary<int, int>();

}

public LGraph(int cVertex, bool cDirected)

: base(cVertex, cDirected)

{

dictionary = new SortedDictionary<int, int>();

adjacencyList = new List<List<Edge<W, D>>>(cVertex);

for (int i = 0; i < cVertex; i++)

{

adjacencyList.Add(new List<Edge<W, D>>());

dictionary.Add(i, i);

}

}

public LGraph(int cVertex, int cEdge, bool cDirected)

: base(cVertex, cDirected)

{

adjacencyList = new List<List<Edge<W, D>>>(cVertex);

dictionary = new SortedDictionary<int, int>();

for (int i = 0; i < cVertex; i++)

{

adjacencyList.Add(new List<Edge<W, D>>());

dictionary.Add(i, i);

}

Random rand = new Random();

for (int i = 0; i < cEdge; )

{

int vertex1 = rand.Next(cVertex);

int vertex2 = rand.Next(cVertex);

bool edgeInserted = addEdge(vertex1, vertex2);

if (edgeInserted) i++;

}

}

public LGraph(int cVertex, int cEdge, List<List<Edge<W, D>>> list, bool cDirected)

: base(cVertex, cEdge, cDirected)

{

adjacencyList = list;

}

public override bool getType()

{

return true;

}

public override bool addVertex(int vertexNumber)

{

if (vertexNumber < 0) return false;

dictionary.Add(vertexNumber, adjacencyList.Count);

adjacencyList.Add(new List<Edge<W, D>>());

increaseVerticesCount();

return true;

}

public override bool removeVertex(int vertexNumber)

{

if (vertexNumber < 0) return false;

else

{

int deleteIndex = dictionary[vertexNumber];

decreaseEdgesCount(adjacencyList[deleteIndex].Count);

adjacencyList.RemoveAt(deleteIndex);

decreaseVerticesCount();

foreach (List<Edge<W, D>> list in adjacencyList)

{

for (int i = 0; i < list.Count; )

{

if (list[i].Vertex2 == deleteIndex)

{

list.RemoveAt(i);

decreaseEdgesCount();

}

else

{

if (list[i].Vertex1 > deleteIndex) list[i].Vertex1--;

if (list[i].Vertex2 > deleteIndex) list[i].Vertex2--;

i++;

}

}

}

dictionary.Remove(vertexNumber);

for (int key = 0; key <= MAXVERTICESCOUNT; key++)

{

int value;

if (dictionary.TryGetValue(key, out value))

{

if (value > vertexNumber)

{

dictionary.Remove(key);

dictionary.Add(key, value - 1);

}

}

}

return true;

}

}

public override bool addEdge(int vertex1, int vertex2)

{

if (vertex1 == vertex2 || !dictionary.ContainsKey(vertex1) || !dictionary.ContainsKey(vertex2)) return false;

if (hasEdge(vertex1, vertex2)) return false;

int source = dictionary[vertex1];

int destanation = dictionary[vertex2];

Edge<W, D> newEdge = new Edge<W, D>(source, destanation);

bool inserted = false;

if (source < 0 || destanation < 0 || source == destanation) return false;

if (adjacencyList[source].Count == 0)

{

adjacencyList[source].Add(newEdge);

increaseEdgesCount();

inserted = true;

}

else

{

foreach (Edge<W, D> edge in adjacencyList[source])

{

if (edge.Vertex1 == source && edge.Vertex2 == destanation)

return false;

}

adjacencyList[source].Add(newEdge);

increaseEdgesCount();

inserted = true;

}

if (inserted && !isDirected())

{

Edge<W, D> reverseEdge = new Edge<W, D>(destanation, source);

adjacencyList[destanation].Add(reverseEdge);

}

return inserted;

}

public override bool addEdge(Edge<W, D> edge)

{

if (edge == null) return false;

adjacencyList[edge.Vertex1].Add(edge);

increaseEdgesCount();

if (!isDirected())

{

Edge<W, D> reverseEdge = new Edge<W, D>(edge.Vertex2, edge.Vertex1, edge.Weight, edge.Data);

adjacencyList[edge.Vertex2].Add(reverseEdge);

}

return true;

}

public override bool removeEdge(int vertex1, int vertex2)

{

if (vertex1 == vertex2 || !dictionary.ContainsKey(vertex1) || !dictionary.ContainsKey(vertex2)) return false;

if (!hasEdge(vertex1, vertex2)) return false;

int source = dictionary[vertex1];

int destanation = dictionary[vertex2];

if (source > getVerticesCount() - 1 || destanation > getVerticesCount() - 1 || source < 0 || destanation < 0) return false;

for (int i = 0; i < adjacencyList[source].Count; i++)

if (adjacencyList[source][i].Vertex2 == destanation)

{

adjacencyList[source].RemoveAt(i);

decreaseEdgesCount();

if (!isDirected())

{

for (int j = 0; j < adjacencyList[destanation].Count; j++)

{

if (adjacencyList[destanation][j].Vertex2 == source)

adjacencyList[destanation].RemoveAt(j);

}

}

return true;

}

return false;

}

public override bool hasEdge(int vertex1, int vertex2)

{

int source;

int destanation;

if (dictionary.TryGetValue(vertex1, out source) && dictionary.TryGetValue(vertex2, out destanation))

{

if (source > getVerticesCount() - 1 || destanation > getVerticesCount() - 1 || source < 0 || destanation < 0 || source == destanation) return false;

for (int i = 0; i < adjacencyList[source].Count; i++)

if (adjacencyList[source][i].Vertex2 == destanation) return true;

}

return false;

}

public override W getEdgeWeight(int vertex1, int vertex2)

{

if (vertex1 == vertex2 || !dictionary.ContainsKey(vertex1) || !dictionary.ContainsKey(vertex2)) throw new ArgumentException();

if (!hasEdge(vertex1, vertex2)) throw new ArgumentException();

int source = dictionary[vertex1];

int destanation = dictionary[vertex2];

if (source > getVerticesCount() - 1 || destanation > getVerticesCount() - 1 || source < 0 || destanation < 0) throw new ArgumentOutOfRangeException("this edge does not exist");

for (int i = 0; i < adjacencyList[source].Count; i++)

if (adjacencyList[source][i].Vertex2 == destanation) return adjacencyList[source][i].Weight;

throw new ArgumentOutOfRangeException("Ребро не существует");

}

public override bool setEdgeWeight(int vertex1, int vertex2, W weight)

{

if (vertex1 == vertex2 || !dictionary.ContainsKey(vertex1) || !dictionary.ContainsKey(vertex2)) return false;

if (!hasEdge(vertex1, vertex2)) return false;

int source = dictionary[vertex1];

int destanation = dictionary[vertex2];

if (source > getVerticesCount() - 1 || destanation > getVerticesCount() - 1 || source < 0 || destanation < 0) return false;

for (int i = 0; i < adjacencyList[source].Count; i++)

if (adjacencyList[source][i].Vertex2 == destanation)

{

adjacencyList[source][i].Weight = weight;

return true;

}

return false;

}

public override D getEdgeData(int vertex1, int vertex2)

{

if (vertex1 == vertex2 || !dictionary.ContainsKey(vertex1) || !dictionary.ContainsKey(vertex2)) throw new ArgumentException();

if (!hasEdge(vertex1, vertex2)) throw new ArgumentException();

int source = dictionary[vertex1];

int destanation = dictionary[vertex2];

if (source > getVerticesCount() - 1 || destanation > getVerticesCount() - 1 || source < 0 || destanation < 0) throw new ArgumentOutOfRangeException("this edge does not exist");

for (int i = 0; i < adjacencyList[source].Count; i++)

if (adjacencyList[source][i].Vertex2 == destanation) return adjacencyList[source][i].Data;

throw new ArgumentOutOfRangeException("Ребро не существует");

}

public override bool setEdgeData(int vertex1, int vertex2, D data)

{

if (vertex1 == vertex2 || !dictionary.ContainsKey(vertex1) || !dictionary.ContainsKey(vertex2)) return false;

if (!hasEdge(vertex1, vertex2)) return false;

int source = dictionary[vertex1];

int destanation = dictionary[vertex2];

if (source > getVerticesCount() - 1 || destanation > getVerticesCount() - 1 || source < 0 || destanation < 0) return false;

for (int i = 0; i < adjacencyList[source].Count; i++)

if (adjacencyList[source][i].Vertex2 == destanation)

{

adjacencyList[source][i].Data = data;

return true;

}

return false;

}

public Object Clone()

{

return new LGraph<W, D>(getVerticesCount(), getEdgesCount(), adjacencyList, isDirected());

}

public override Graph<W, D> toListGraph()

{

return this;

}

public override Graph<W, D> toMatrixGraph()

{

MGraph<W, D> mGraph = new MGraph<W, D>(getVerticesCount(), isDirected());

foreach (List<Edge<W, D>> listOfEdges in adjacencyList)

foreach (Edge<W, D> edge in listOfEdges)

{

mGraph.addEdge(edge);

}

mGraph.dictionary = dictionary;

return mGraph;

}

public override List<int> getNeighbors(int vertexNumber)

{

int currentVertexNeighbor = 0;

List<int> result = new List<int>();

int min = 100;

if (adjacencyList[vertexNumber].Count != 0)

{

foreach (Edge<W, D> edge in adjacencyList[vertexNumber])

{

if (edge.Vertex2 < min && edge.Vertex2 >= currentVertexNeighbor)

{

min = edge.Vertex2;

}

}

result.Add(min);

currentVertexNeighbor = min;

}

while (true)

{

int old = currentVertexNeighbor;

min = 100;

foreach (Edge<W, D> edge in adjacencyList[vertexNumber])

{

if (edge.Vertex2 < min && edge.Vertex2 > old)

{

min = edge.Vertex2;

}

}

if (min == 100)

{

currentVertexNeighbor = 0;

return result;

}

currentVertexNeighbor = min;

result.Add(currentVertexNeighbor);

}

}

public class VertexIterator<W, D> : Iterator<W, D>

{

public VertexIterator(Graph<W, D> graphC)

: base(graphC)

{

}

public override void begin()

{

if (graph.getVerticesCount() == 0)

{

currentPosition = null;

return;

}

int min = 100;

foreach (KeyValuePair<int, int> entry in graph.dictionary)

{

if (entry.Key < min) min = entry.Key;

}

currentPosition = new Edge<W, D>(min, 100);

}

public override void end()

{

if (graph.getVerticesCount() == 0)

{

currentPosition = null;

return;

}

int max = 0;

foreach (KeyValuePair<int, int> entry in graph.dictionary)

{

if (entry.Key > max) max = entry.Key;

}

currentPosition = new Edge<W, D>(max, 100);

}

public override void next()

{

if (currentPosition == null)

{

return;

}

int min = 100;

int old = currentPosition.Vertex1;

foreach (KeyValuePair<int, int> entry in graph.dictionary)

{

if (entry.Key < min && entry.Key > old) min = entry.Key;

}

if (min != 100)

{

currentPosition = new Edge<W, D>(min, 100);

}

else

{

currentPosition = null;

}

}

public override Edge<W, D> state()

{

return currentPosition;

}

}

public class EdgeIterator<W, D> : Iterator<W, D>

{

int lastI = 0;

int lastJ = 0;

int edgesCount = 0;

public EdgeIterator(Graph<W, D> graphC)

: base(graphC)

{

}

public override void begin()

{

if (graph.getVerticesCount() == 0)

{

currentPosition = null;

return;

}

if (graph.isDirected())

{

int i = 0;

int j = 0;

bool isExist = false;

while (!isExist)

{

if (i == ((LGraph<W, D>)graph).adjacencyList.Count)

{

currentPosition = null;

return;

}

if (((LGraph<W, D>)graph).adjacencyList[i].Count == 0) i++;

else

{

isExist = true;

}

}

int source = ((LGraph<W, D>)graph).adjacencyList[i][j].Vertex1;

int destanation = ((LGraph<W, D>)graph).adjacencyList[i][j].Vertex2;

int sourceVertex = 0;

int destanationVertex = 0;

foreach (KeyValuePair<int, int> entry in graph.dictionary)

{

if (entry.Value == source) sourceVertex = entry.Key;

if (entry.Value == destanation) destanationVertex = entry.Key;

}

currentPosition = new Edge<W, D>(sourceVertex, destanationVertex, graph.getEdgeWeight(sourceVertex, destanationVertex), graph.getEdgeData(sourceVertex, destanationVertex));

lastI = i;

lastJ = j;

edgesCount = 1;

}

else

{

for (int i = 0; i <= MAXVERTICESCOUNT; i++)

{

for (int j = 0; j <= MAXVERTICESCOUNT; j++)

{

if (!graph.dictionary.ContainsKey(i) || !graph.dictionary.ContainsKey(j)) continue;

if (graph.hasEdge(graph.dictionary[i], graph.dictionary[j]))

{

int sourceVertex = 0;

int destanationVertex = 0;

foreach (KeyValuePair<int, int> entry in graph.dictionary)

{

if (entry.Value == i) sourceVertex = entry.Key;

if (entry.Value == j) destanationVertex = entry.Key;

}

currentPosition = new Edge<W, D>(sourceVertex, destanationVertex, graph.getEdgeWeight(sourceVertex, destanationVertex), graph.getEdgeData(sourceVertex, destanationVertex));

lastI = i;

lastJ = j;

edgesCount = 1;

return;

}

}

lastJ = i;

}

}

}

public override void end()

{

if (graph.getVerticesCount() == 0)

{

currentPosition = null;

return;

}

if (graph.isDirected())

{

int i = ((LGraph<W, D>)graph).adjacencyList.Count - 1;

bool isExist = false;

while (!isExist)

{

if (i == -1)

{

currentPosition = null;

return;

}

if (((LGraph<W, D>)graph).adjacencyList[i].Count == 0) i--;

else

{

isExist = true;

}

}

int j = ((LGraph<W, D>)graph).adjacencyList[i].Count - 1;

int source = ((LGraph<W, D>)graph).adjacencyList[i][j].Vertex1;

int destanation = ((LGraph<W, D>)graph).adjacencyList[i][j].Vertex2;

int sourceVertex = i;

int destanationVertex = j;

foreach (KeyValuePair<int, int> entry in graph.dictionary)

{

if (entry.Value == source) sourceVertex = entry.Key;

if (entry.Value == destanation) destanationVertex = entry.Key;

}

currentPosition = new Edge<W, D>(sourceVertex, destanationVertex, graph.getEdgeWeight(sourceVertex, destanationVertex), graph.getEdgeData(sourceVertex, destanationVertex));

edgesCount = graph.getEdgesCount();

}

else

{

for (int i = MAXVERTICESCOUNT; i >= 0; i--)

for (int j = MAXVERTICESCOUNT; j >= i; j--)

{

if (i == j || !graph.dictionary.ContainsKey(i) || !graph.dictionary.ContainsKey(j)) continue;

if (graph.hasEdge(i, j))

{

int sourceVertex = 0;

int destanationVertex = 0;

foreach (KeyValuePair<int, int> entry in graph.dictionary)

{

if (entry.Value == i) sourceVertex = entry.Key;

if (entry.Value == j) destanationVertex = entry.Key;

}

currentPosition = new Edge<W, D>(sourceVertex, destanationVertex, graph.getEdgeWeight(sourceVertex, destanationVertex), graph.getEdgeData(sourceVertex, destanationVertex));

lastI = i;

lastJ = j;

edgesCount = graph.getEdgesCount();

return;

}

}

}

}

public override void next()

{

if (currentPosition == null)

{

return;

}

if (edgesCount == graph.getEdgesCount())

{

currentPosition = null;

return;

}

if (graph.isDirected())

{

int i = lastI;

int j = lastJ + 1;

if (j == ((LGraph<W, D>)graph).adjacencyList[i].Count)

{

j = 0;

i++;

}

bool isExist = false;

while (!isExist)

{

if (i == ((LGraph<W, D>)graph).adjacencyList.Count)

{

currentPosition = null;

return;

}

if (((LGraph<W, D>)graph).adjacencyList[i].Count == 0) i++;

else

{

isExist = true;

}

}

if (i == ((LGraph<W, D>)graph).adjacencyList.Count)

{

currentPosition = null;

return;

}

int source = ((LGraph<W, D>)graph).adjacencyList[i][j].Vertex1;

int destanation = ((LGraph<W, D>)graph).adjacencyList[i][j].Vertex2;

int sourceVertex = 0;

int destanationVertex = 0;

foreach (KeyValuePair<int, int> entry in graph.dictionary)

{

if (entry.Value == source) sourceVertex = entry.Key;

if (entry.Value == destanation) destanationVertex = entry.Key;

}

currentPosition = new Edge<W, D>(sourceVertex, destanationVertex, graph.getEdgeWeight(sourceVertex, destanationVertex), graph.getEdgeData(sourceVertex, destanationVertex));

edgesCount++;

lastI = i;

lastJ = j;

return;

}

else

{

for (int i = lastI; i <= MAXVERTICESCOUNT; i++)

{

for (int j = lastJ + 1; j <= MAXVERTICESCOUNT; j++)

{

if (i == j || !graph.dictionary.ContainsKey(i) || !graph.dictionary.ContainsKey(j)) continue;

if (graph.hasEdge(i, j))

{

int sourceVertex = i;

int destanationVertex = j;

currentPosition = new Edge<W, D>(sourceVertex, destanationVertex, graph.getEdgeWeight(sourceVertex, destanationVertex), graph.getEdgeData(sourceVertex, destanationVertex));

lastI = i;

lastJ = j;

edgesCount++;

return;

}

}

lastJ = i;

}

}

}

public override Edge<W, D> state()

{

return currentPosition;

}

}

public class IncomingEdgesIterator<W, D> : Iterator<W, D>

{

int lastI = 0;

int vertexNumb = -2;

public IncomingEdgesIterator(Graph<W, D> graphC, int vertexNumbC)

: base(graphC)

{

vertexNumb = graph.dictionary[vertexNumbC];

begin();

}

public override void begin()

{

if (vertexNumb == -2) return;

if (graph.getVerticesCount() == 0)

{

currentPosition = null;

return;

}

for (int i = 0; i < graph.getVerticesCount(); i++)

{

int source = 0;

int destanation = 0;

foreach (KeyValuePair<int, int> entry in graph.dictionary)

{

if (entry.Value == i) source = entry.Key;

if (entry.Value == vertexNumb) destanation = entry.Key;

}

if (graph.hasEdge(source, destanation))

{

currentPosition = new Edge<W, D>(source, destanation, graph.getEdgeWeight(source, destanation), graph.getEdgeData(source, destanation));

lastI = i;

return;

}

if (i == graph.getVerticesCount() - 1)

{

currentPosition = null;

}

}

}

public override void end()

{

if (graph.getVerticesCount() == 0)

{

currentPosition = null;

return;

}

for (int i = graph.getVerticesCount() - 1; i >= 0; i--)

{

int source = 0;

int destanation = 0;

foreach (KeyValuePair<int, int> entry in graph.dictionary)

{

if (entry.Value == i) source = entry.Key;

if (entry.Value == vertexNumb) destanation = entry.Key;

}

if (graph.hasEdge(source, destanation))

{

currentPosition = new Edge<W, D>(source, destanation, graph.getEdgeWeight(source, destanation), graph.getEdgeData(source, destanation));

lastI = i;

return;

}

if (i == 0)

{

currentPosition = null;

}

}

}

public override void next()

{

if (currentPosition == null)

{

return;

}

int i;

for (i = lastI + 1; i < graph.getVerticesCount(); i++)

{

int source = 0;

int destanation = 0;

foreach (KeyValuePair<int, int> entry in graph.dictionary)

{

if (entry.Value == i) source = entry.Key;

if (entry.Value == vertexNumb) destanation = entry.Key;

}

if (graph.hasEdge(source, destanation))

{

currentPosition = new Edge<W, D>(source, destanation, graph.getEdgeWeight(source, destanation), graph.getEdgeData(source, destanation));

lastI = i;

return;

}

}

if (i == graph.getVerticesCount())

{

currentPosition = null;

}

}

public override Edge<W, D> state()

{

return currentPosition;

}

}

public class OutGoingEdgesIterator<W, D> : Iterator<W, D>

{

int lastI = 0;

int vertexNumb = -2;

public OutGoingEdgesIterator(Graph<W, D> graphC, int vertexNumbC)

: base(graphC)

{

vertexNumb = graph.dictionary[vertexNumbC];

begin();

}

public override void begin()

{

if (vertexNumb == -2) return;

if (graph.getVerticesCount() == 0)

{

currentPosition = null;

return;

}

if (((LGraph<W, D>)graph).adjacencyList[vertexNumb].Count == 0)

{

currentPosition = null;

return;

}

int i = 0;

int source = ((LGraph<W, D>)graph).adjacencyList[vertexNumb][i].Vertex1;

int destanation = ((LGraph<W, D>)graph).adjacencyList[vertexNumb][i].Vertex2;

bool sourceOK = false;

bool destanationOK = false;

foreach (KeyValuePair<int, int> entry in graph.dictionary)

{

if (entry.Value == source && !sourceOK)

{

source = entry.Key;

sourceOK = true;

}

if (entry.Value == destanation && !destanationOK)

{

destanation = entry.Key;

destanationOK = true;

}

}

currentPosition = new Edge<W, D>(source, destanation, graph.getEdgeWeight(source, destanation), graph.getEdgeData(source, destanation));

lastI = i;

}

public override void end()

{

if (graph.getVerticesCount() == 0)

{

currentPosition = null;

return;

}

if (((LGraph<W, D>)graph).adjacencyList[vertexNumb].Count == 0)

{

currentPosition = null;

return;

}

int i = ((LGraph<W, D>)graph).adjacencyList[vertexNumb].Count - 1;

int source = ((LGraph<W, D>)graph).adjacencyList[vertexNumb][i].Vertex1;

int destanation = ((LGraph<W, D>)graph).adjacencyList[vertexNumb][i].Vertex2;

bool sourceOK = false;

bool destanationOK = false;

foreach (KeyValuePair<int, int> entry in graph.dictionary)

{

if (entry.Value == source && !sourceOK)

{

source = entry.Key;

sourceOK = true;

}

if (entry.Value == destanation && !destanationOK)

{

destanation = entry.Key;

destanationOK = true;

}

}

currentPosition = new Edge<W, D>(source, destanation, graph.getEdgeWeight(source, destanation), graph.getEdgeData(source, destanation));

lastI = i;

}

public override void next()

{

if (currentPosition == null)

{

return;

}

int i = lastI + 1;

if (i == ((LGraph<W, D>)graph).adjacencyList[vertexNumb].Count)

{

currentPosition = null;

return;

}

int source = ((LGraph<W, D>)graph).adjacencyList[vertexNumb][i].Vertex1;

int destanation = ((LGraph<W, D>)graph).adjacencyList[vertexNumb][i].Vertex2;

bool sourceOK = false;

bool destanationOK = false;

foreach (KeyValuePair<int, int> entry in graph.dictionary)

{

if (entry.Value == source && !sourceOK)

{

source = entry.Key;

sourceOK = true;

}

if (entry.Value == destanation && !destanationOK)

{

destanation = entry.Key;

destanationOK = true;

}

}

currentPosition = new Edge<W, D>(source, destanation, graph.getEdgeWeight(source, destanation), graph.getEdgeData(source, destanation));

lastI = i;

}

public override Edge<W, D> state()

{

return currentPosition;

}

}

}

}

MGraph.cs

using System;

{

class MGraph<W, D> : Graph<W, D>, ICloneable

{

Edge<W, D>[,] adjacencyMatrix;

public MGraph(int cVertex, bool cDirected)

: base(cVertex, cDirected)

{

adjacencyMatrix = new Edge<W, D>[cVertex * 2, cVertex * 2];

dictionary = new SortedDictionary<int, int>();

for (int i = 0; i < cVertex; i++)

{

dictionary.Add(i, i);