get edges api

Author: justcoding121

Algorithm.Sandbox/DataStructures/Graph/AdjacencyList/DiGraph.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Algorithm.Sandbox.DataStructures.Graph.AdjacencyList
 {
@@ -187,6 +188,26 @@ public bool HasEdge(T source, T dest)
                 && Vertices[dest].InEdges.Contains(Vertices[source]);
         }
 
+        public List<T> GetAllOutEdges(T vertex)
+        {
+            if (!Vertices.ContainsKey(vertex))
+            {
+                throw new ArgumentException("vertex is not in this graph.");
+            }
+
+            return Vertices[vertex].OutEdges.Select(x=>x.Value).ToList();
+        }
+
+        public List<T> GetAllInEdges(T vertex)
+        {
+            if (!Vertices.ContainsKey(vertex))
+            {
+                throw new ArgumentException("vertex is not in this graph.");
+            }
+
+            return Vertices[vertex].InEdges.Select(x => x.Value).ToList();
+        }
+
         /// <summary>
         /// returns the vertex object with given value
         /// O(1) complexity

Algorithm.Sandbox/DataStructures/Graph/AdjacencyList/Graph.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Algorithm.Sandbox.DataStructures.Graph.AdjacencyList
 {
@@ -181,6 +182,16 @@ public bool HasEdge(T source, T dest)
                 && Vertices[dest].Edges.Contains(Vertices[source]);
         }
 
+        public List<T> GetAllEdges(T vertex)
+        {
+            if (!Vertices.ContainsKey(vertex))
+            {
+                throw new ArgumentException("vertex is not in this graph.");
+            }
+
+            return Vertices[vertex].Edges.Select(x => x.Value).ToList();
+        }
+
         /// <summary>
         /// returns the vertex object with given value
         ///  O(1) complexity

Algorithm.Sandbox/DataStructures/Graph/AdjacencyList/WeightedDiGraph.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Algorithm.Sandbox.DataStructures.Graph.AdjacencyList
 {
@@ -190,6 +191,26 @@ public bool HasEdge(T source, T dest)
              && Vertices[dest].InEdges.ContainsKey(Vertices[source]);
         }
 
+        public List<Tuple<T, W>> GetAllOutEdges(T vertex)
+        {
+            if (!Vertices.ContainsKey(vertex))
+            {
+                throw new ArgumentException("vertex is not in this graph.");
+            }
+
+            return Vertices[vertex].OutEdges.Select(x =>new Tuple<T,W>(x.Key.Value, x.Value)).ToList();
+        }
+
+        public List<Tuple<T, W>> GetAllInEdges(T vertex)
+        {
+            if (!Vertices.ContainsKey(vertex))
+            {
+                throw new ArgumentException("vertex is not in this graph.");
+            }
+
+            return Vertices[vertex].InEdges.Select(x => new Tuple<T, W>(x.Key.Value, x.Value)).ToList();
+        }
+
         /// <summary>
         /// returns the vertex with given value
         /// O(1) complexity

Algorithm.Sandbox/DataStructures/Graph/AdjacencyList/WeightedGraph.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Algorithm.Sandbox.DataStructures.Graph.AdjacencyList
 {
@@ -183,6 +184,17 @@ public bool HasEdge(T source, T dest)
 
         }
 
+
+        public List<Tuple<T, W>> GetAllEdges(T vertex)
+        {
+            if (!Vertices.ContainsKey(vertex))
+            {
+                throw new ArgumentException("vertex is not in this graph.");
+            }
+
+            return Vertices[vertex].Edges.Select(x => new Tuple<T, W>(x.Key.Value, x.Value)).ToList();
+        }
+
         /// <summary>
         /// Find the Vertex with given value
         ///  O(1) complexity

Algorithm.Sandbox/DataStructures/Graph/AdjacencyMatrix/DiGraph.cs

@@ -192,6 +192,50 @@ public bool HasEdge(T source, T dest)
             return false;
         }
 
+        public List<T> GetAllOutEdges(T vertex)
+        {
+            if (!vertexIndices.ContainsKey(vertex))
+            {
+                throw new ArgumentException("vertex is not in this graph.");
+            }
+
+            var index = vertexIndices[vertex];
+
+            var result = new List<T>();
+
+            for (int i = 0; i < maxSize; i++)
+            {
+                if(matrix[index].Get(i))
+                {
+                    result.Add(reverseVertexIndices[i]);
+                }
+            }
+
+            return result;
+        }
+
+        public List<T> GetAllInEdges(T vertex)
+        {
+            if (!vertexIndices.ContainsKey(vertex))
+            {
+                throw new ArgumentException("vertex is not in this graph.");
+            }
+
+            var index = vertexIndices[vertex];
+
+            var result = new List<T>();
+
+            for (int i = 0; i < maxSize; i++)
+            {
+                if (matrix[i].Get(index))
+                {
+                    result.Add(reverseVertexIndices[i]);
+                }
+            }
+
+            return result;
+        }
+
         private void doubleMatrixSize()
         {
             var newMatrix = new BitArray[maxSize * 2];

Algorithm.Sandbox/DataStructures/Graph/AdjacencyMatrix/Graph.cs

@@ -193,6 +193,28 @@ public bool HasEdge(T source, T dest)
             return false;
         }
 
+        public List<T> GetAllEdges(T vertex)
+        {
+            if (!vertexIndices.ContainsKey(vertex))
+            {
+                throw new ArgumentException("vertex is not in this graph.");
+            }
+
+            var index = vertexIndices[vertex];
+
+            var result = new List<T>();
+
+            for (int i = 0; i < maxSize; i++)
+            {
+                if (matrix[i].Get(index))
+                {
+                    result.Add(reverseVertexIndices[i]);
+                }
+            }
+
+            return result;
+        }
+
         private void doubleMatrixSize()
         {
             var newMatrix = new BitArray[maxSize * 2];

Algorithm.Sandbox/DataStructures/Graph/AdjacencyMatrix/WeightedDiGraph.cs

@@ -196,6 +196,50 @@ public bool HasEdge(T source, T dest)
             return false;
         }
 
+        public List<Tuple<T, W>> GetAllOutEdges(T vertex)
+        {
+            if (!vertexIndices.ContainsKey(vertex))
+            {
+                throw new ArgumentException("vertex is not in this graph.");
+            }
+
+            var index = vertexIndices[vertex];
+
+            var result = new List<Tuple<T, W>>();
+
+            for (int i = 0; i < maxSize; i++)
+            {
+                if (!matrix[index,i].Equals(default(W)))
+                {
+                    result.Add(new Tuple<T,W>(reverseVertexIndices[i], matrix[index, i]));
+                }
+            }
+
+            return result;
+        }
+
+        public List<Tuple<T, W>> GetAllInEdges(T vertex)
+        {
+            if (!vertexIndices.ContainsKey(vertex))
+            {
+                throw new ArgumentException("vertex is not in this graph.");
+            }
+
+            var index = vertexIndices[vertex];
+
+            var result = new List<Tuple<T, W>>();
+
+            for (int i = 0; i < maxSize; i++)
+            {
+                if (!matrix[i, index].Equals(default(W)))
+                {
+                    result.Add(new Tuple<T, W>(reverseVertexIndices[i], matrix[i, index]));
+                }
+            }
+
+            return result;
+        }
+
         private void doubleMatrixSize()
         {
             var newMatrix = new W[maxSize * 2, maxSize * 2];

Algorithm.Sandbox/DataStructures/Graph/AdjacencyMatrix/WeightedGraph.cs

@@ -200,6 +200,28 @@ public bool HasEdge(T source, T dest)
             return false;
         }
 
+        public List<Tuple<T,W>> GetAllEdges(T vertex)
+        {
+            if (!vertexIndices.ContainsKey(vertex))
+            {
+                throw new ArgumentException("vertex is not in this graph.");
+            }
+
+            var index = vertexIndices[vertex];
+
+            var result = new List<Tuple<T, W>>();
+
+            for (int i = 0; i < maxSize; i++)
+            {
+                if (!matrix[i,index].Equals(default(W)))
+                {
+                    result.Add(new Tuple<T, W>(reverseVertexIndices[i], matrix[i, index]));
+                }
+            }
+
+            return result;
+        }
+
         private void doubleMatrixSize()
         {
             var newMatrix = new W[maxSize * 2, maxSize * 2];