matrix graph to generic IGraph

Author: justcoding121

src/Advanced.Algorithms/DataStructures/Graph/AdjacencyMatrix/DiGraph.cs

@@ -6,17 +6,17 @@
 namespace Advanced.Algorithms.DataStructures.Graph.AdjacencyMatrix
 {
     /// <summary>
-    /// A directed graph implementation using dynamically growinng/shrinking adjacency matrix array.
+    /// A directed graph implementation using dynamically growing/shrinking adjacency matrix array.
     /// IEnumerable enumerates all vertices.
     /// </summary>
     public class DiGraph<T> : IGraph<T>, IDiGraph<T>, IEnumerable<T>
     {
+        private BitArray[] matrix;
+
         private Dictionary<T, int> vertexIndices;
         private Dictionary<int, T> reverseVertexIndices;
         private Dictionary<T, DiGraphVertex<T>> vertexObjects;
 
-        private BitArray[] matrix;
-
         private int maxSize => matrix.Length;
         private int usedSize;
         private int nextAvailableIndex;

src/Advanced.Algorithms/DataStructures/Graph/AdjacencyMatrix/Graph.cs

@@ -5,37 +5,50 @@
 
 namespace Advanced.Algorithms.DataStructures.Graph.AdjacencyMatrix
 {
-
     /// <summary>
-    /// A directed graph implementation using dynamically growinng/shrinking adjacency matrix array.
+    /// A directed graph implementation using dynamically growing/shrinking adjacency matrix array.
     /// IEnumerable enumerates all vertices.
     /// </summary>
-    public class Graph<T> : IEnumerable<T>
+    public class Graph<T> : IGraph<T>, IEnumerable<T>
     {
-        public int VerticesCount => usedSize;
+        private BitArray[] matrix;
 
         private Dictionary<T, int> vertexIndices;
         private Dictionary<int, T> reverseVertexIndices;
+        private Dictionary<T, GraphVertex<T>> vertexObjects;
 
-        private BitArray[] matrix;
-
-        private int maxSize;
+        private int maxSize => matrix.Length;
         private int usedSize;
         private int nextAvailableIndex;
 
+        public int VerticesCount => usedSize;
+        public bool IsWeightedGraph => false;
+
         public Graph()
         {
-            maxSize = 1;
             vertexIndices = new Dictionary<T, int>();
             reverseVertexIndices = new Dictionary<int, T>();
-            matrix = new BitArray[maxSize];
+            vertexObjects = new Dictionary<T, GraphVertex<T>>();
+
+            matrix = new BitArray[1];
 
             for (int i = 0; i < maxSize; i++)
             {
                 matrix[i] = new BitArray(maxSize);
             }
         }
 
+        public IGraphVertex<T> ReferenceVertex => getReferenceVertex();
+        private GraphVertex<T> getReferenceVertex()
+        {
+            if (this.VerticesCount == 0)
+            {
+                throw new Exception("Empty graph.");
+            }
+
+            return vertexObjects[this.First()];
+        }
+
         /// <summary>
         /// Add a new vertex to this graph.
         /// Time complexity: O(1).
@@ -64,6 +77,7 @@ public void AddVertex(T value)
 
             vertexIndices.Add(value, nextAvailableIndex);
             reverseVertexIndices.Add(nextAvailableIndex, value);
+            vertexObjects.Add(value, new GraphVertex<T>(this, value));
 
             nextAvailableIndex++;
             usedSize++;
@@ -103,6 +117,7 @@ public void RemoveVertex(T value)
 
             reverseVertexIndices.Remove(index);
             vertexIndices.Remove(value);
+            vertexObjects.Remove(value);
 
             usedSize--;
 
@@ -199,19 +214,37 @@ public IEnumerable<T> Edges(T vertex)
 
             var index = vertexIndices[vertex];
 
-            var result = new List<T>();
+            for (int i = 0; i < maxSize; i++)
+            {
+                if (matrix[i].Get(index))
+                {
+                    yield return reverseVertexIndices[i];
+                }
+            }
+        }
+
+        public int EdgesCount(T vertex)
+        {
+            if (!vertexIndices.ContainsKey(vertex))
+            {
+                throw new ArgumentException("vertex is not in this graph.");
+            }
+
+            var count = 0;
+            var index = vertexIndices[vertex];
 
             for (int i = 0; i < maxSize; i++)
             {
                 if (matrix[i].Get(index))
                 {
-                    result.Add(reverseVertexIndices[i]);
+                    count++;
                 }
             }
 
-            return result;
+            return count;
         }
 
+
         private void doubleMatrixSize()
         {
             var newMatrix = new BitArray[maxSize * 2];
@@ -237,7 +270,7 @@ private void doubleMatrixSize()
             {
                 for (int j = i; j < maxSize; j++)
                 {
-                    if (matrix[i].Get(j) && matrix[j].Get(i) 
+                    if (matrix[i].Get(j) && matrix[j].Get(i)
                         && reverseVertexIndices.ContainsKey(i)
                         && reverseVertexIndices.ContainsKey(j))
                     {
@@ -253,7 +286,6 @@ private void doubleMatrixSize()
             matrix = newMatrix;
             vertexIndices = newVertexIndices;
             reverseVertexIndices = newReverseIndices;
-            maxSize *= 2;
         }
 
         private void halfMatrixSize()
@@ -281,7 +313,7 @@ private void halfMatrixSize()
             {
                 for (int j = i; j < maxSize; j++)
                 {
-                    if (matrix[i].Get(j) && matrix[j].Get(i) 
+                    if (matrix[i].Get(j) && matrix[j].Get(i)
                         && reverseVertexIndices.ContainsKey(i)
                         && reverseVertexIndices.ContainsKey(j))
                     {
@@ -297,9 +329,10 @@ private void halfMatrixSize()
             matrix = newMatrix;
             vertexIndices = newVertexIndices;
             reverseVertexIndices = newReverseIndices;
-            maxSize /= 2;
         }
 
+        public IEnumerable<IGraphVertex<T>> VerticesAsEnumberable => vertexObjects.Select(x => x.Value);
+
         IEnumerator IEnumerable.GetEnumerator()
         {
             return GetEnumerator();
@@ -309,5 +342,95 @@ public IEnumerator<T> GetEnumerator()
         {
             return vertexIndices.Select(x => x.Key).GetEnumerator();
         }
+
+        public bool ContainsVertex(T key)
+        {
+            return vertexObjects.ContainsKey(key);
+        }
+
+        public IGraphVertex<T> GetVertex(T key)
+        {
+            return vertexObjects[key];
+        }
+
+        IGraph<T> IGraph<T>.Clone()
+        {
+            return Clone();
+        }
+
+        public Graph<T> Clone()
+        {
+            var graph = new Graph<T>();
+
+            foreach (var vertex in this)
+            {
+                graph.AddVertex(vertex);
+            }
+
+            foreach (var vertex in this)
+            {
+                foreach (var edge in Edges(vertex))
+                {
+                    graph.AddEdge(vertex, edge);
+                }
+            }
+
+            return graph;
+        }
+
+        private class GraphVertex<T> : IGraphVertex<T>
+        {
+            Graph<T> graph;
+            private int vertexIndex;
+            private T vertexKey;
+
+            private int maxSize => graph.maxSize;
+            private BitArray[] matrix => graph.matrix;
+
+            private Dictionary<T, int> vertexIndices => graph.vertexIndices;
+            private Dictionary<int, T> reverseVertexIndices => graph.reverseVertexIndices;
+
+            internal GraphVertex(Graph<T> graph, T vertexKey)
+            {
+                if (!graph.vertexIndices.ContainsKey(vertexKey))
+                {
+                    throw new ArgumentException("vertex is not in this graph.");
+                }
+
+                this.graph = graph;
+                this.vertexKey = vertexKey;
+                this.vertexIndex = graph.vertexIndices[vertexKey];
+            }
+
+            public T Key => vertexKey;
+
+
+            IEnumerable<IEdge<T>> IGraphVertex<T>.Edges => graph.Edges(vertexKey)
+              .Select(x => new Edge<T, int>(graph.vertexObjects[x], 1));
+
+            public IEdge<T> GetOutEdge(IGraphVertex<T> targetVertex)
+            {
+                if (!vertexIndices.ContainsKey(targetVertex.Key))
+                {
+                    throw new ArgumentException("vertex is not in this graph.");
+                }
+
+                var index = vertexIndices[targetVertex.Key];
+                var key = targetVertex as GraphVertex<T>;
+                return new Edge<T, int>(targetVertex, 1);
+            }
+
+            public IEdge<T> GetEdge(IGraphVertex<T> targetVertex)
+            {
+                if (!vertexIndices.ContainsKey(targetVertex.Key))
+                {
+                    throw new ArgumentException("vertex is not in this graph.");
+                }
+
+                var index = vertexIndices[targetVertex.Key];
+                var key = targetVertex as GraphVertex<T>;
+                return new Edge<T, int>(targetVertex, 1);
+            }
+        }
     }
 }

src/Advanced.Algorithms/DataStructures/Graph/AdjacencyMatrix/WeightedDiGraph.cs

@@ -6,23 +6,21 @@
 namespace Advanced.Algorithms.DataStructures.Graph.AdjacencyMatrix
 {
     /// <summary>
-    /// A weighted graph implementation using dynamically growinng/shrinking adjacency matrix array.
+    /// A weighted graph implementation using dynamically growing/shrinking adjacency matrix array.
     /// IEnumerable enumerates all vertices.
     /// </summary>
     public class WeightedDiGraph<T, TW> : IDiGraph<T>, IGraph<T>, IEnumerable<T> where TW : IComparable
     {
-        public int VerticesCount { get; private set; }
-
         private Dictionary<T, int> vertexIndices;
         private Dictionary<int, T> reverseVertexIndices;
         private Dictionary<T, WeightedDiGraphVertex<T, TW>> vertexObjects;
 
         private TW[,] matrix;
         private int maxSize => matrix.GetLength(0);
+        private int nextAvailableIndex;
 
         public bool IsWeightedGraph => true;
-
-        private int nextAvailableIndex;
+        public int VerticesCount => vertexObjects.Count;
 
         public WeightedDiGraph()
         {
@@ -76,7 +74,6 @@ public void AddVertex(T value)
             reverseVertexIndices.Add(nextAvailableIndex, value);
             vertexObjects.Add(value, new WeightedDiGraphVertex<T, TW>(this, value));
             nextAvailableIndex++;
-            VerticesCount++;
 
         }
 
@@ -113,7 +110,6 @@ public void RemoveVertex(T value)
             reverseVertexIndices.Remove(index);
             vertexIndices.Remove(value);
             vertexObjects.Remove(value);
-            VerticesCount--;
 
         }
 
@@ -445,21 +441,18 @@ internal WeightedDiGraphVertex(WeightedDiGraph<T, TW> graph, T vertexKey)
 
             public T Key => vertexKey;
 
-            IEnumerable<IDiEdge<T>> IDiGraphVertex<T>.OutEdges => OutEdges()
+            IEnumerable<IDiEdge<T>> IDiGraphVertex<T>.OutEdges => graph.OutEdges(vertexKey)
                 .Select(x => new DiEdge<T, TW>(graph.vertexObjects[x.Key], x.Value));
 
-            IEnumerable<IDiEdge<T>> IDiGraphVertex<T>.InEdges => InEdges()
+            IEnumerable<IDiEdge<T>> IDiGraphVertex<T>.InEdges => graph.InEdges(vertexKey)
                 .Select(x => new DiEdge<T, TW>(graph.vertexObjects[x.Key], x.Value));
 
-            IEnumerable<IEdge<T>> IGraphVertex<T>.Edges => OutEdges()
+            IEnumerable<IEdge<T>> IGraphVertex<T>.Edges => graph.OutEdges(vertexKey)
               .Select(x => new Edge<T, TW>(graph.vertexObjects[x.Key], x.Value));
 
             public int OutEdgeCount => graph.OutEdgeCount(vertexKey);
             public int InEdgeCount => graph.InEdgeCount(vertexKey);
 
-            public IEnumerable<KeyValuePair<T, TW>> OutEdges() => graph.OutEdges(vertexKey);
-            public IEnumerable<KeyValuePair<T, TW>> InEdges() => graph.InEdges(vertexKey);
-
             public IDiEdge<T> GetOutEdge(IDiGraphVertex<T> targetVertex)
             {
                 if (!vertexIndices.ContainsKey(targetVertex.Key))