コード例 #1
0
        public void Test()
        {
            var g = new UnweightedDirectedGraph <string>();

            g.AddVertex("a");
            g.AddEdge(Edge <string> .Of("b", "c"));
            g.AddEdge(Edge <string> .Of("b", "e"));
            g.AddEdge(Edge <string> .Of("e", "f"));
            g.AddEdge(Edge <string> .Of("f", "d"));

            var node  = g.NodeOf("c");
            var node2 = g.NodeOf("f");

            var allNodes      = g.AllNodes();
            var nbrs          = g.Neighbors(Node <string> .Of("b")).ToList();
            var incidentEdges = g.IncidentEdges(Node <string> .Of("b")).ToList();

            var bfs = new BFS <string>(g);
            var res = bfs.Execute("b");
            var tmp = res;
        }
コード例 #2
0
        public static IUnweightedDirectedGraph <TVertex> ToGraph <TVertex>(
            this IEnumerable <IUnweightedEndpointPair <TVertex> > endpointPairs
            )
        {
            var graph = new UnweightedDirectedGraph <TVertex>();

            foreach (var endpointPair in endpointPairs)
            {
                graph.AddEdge(endpointPair.Origin, endpointPair.Destination);
            }

            return(graph);
        }
コード例 #3
0
        public async Task <IUnweightedDirectedGraph <string> > GetUnweightedDirectedGraphAsync()
        {
            var edges = await EdgeService.GetEdgesAsync();

            var graph = new UnweightedDirectedGraph <string>();

            foreach (var edge in edges)
            {
                graph.AddEdge(edge.Origin, edge.Destination);
            }

            return(graph);
        }
コード例 #4
0
        public static IUnweightedDirectedGraph <TVertex> DepthFirstSearch <TVertex>(
            this IUnweightedDirectedGraph <TVertex> graph,
            TVertex origin
            )
        {
            if (graph == null)
            {
                throw new ArgumentNullException(nameof(graph));
            }
            if (origin == null)
            {
                throw new ArgumentNullException(nameof(origin));
            }

            if (!graph.Vertices.Contains(origin))
            {
                throw new ArgumentException();
            }

            var visited = new HashSet <TVertex>();
            var output  = new UnweightedDirectedGraph <TVertex>();

            var stack = new Stack <TVertex>();

            visited.Add(origin);
            stack.Push(origin);

            while (stack.Count > 0)
            {
                var vertex = stack.Pop();

                bool Predicate(TVertex successorVertex)
                {
                    return(!visited.Contains(successorVertex));
                }

                foreach (var successorVertex in graph.SuccessorVertices(vertex).Where(Predicate))
                {
                    output.AddEdge(vertex, successorVertex);

                    visited.Add(successorVertex);
                    stack.Push(successorVertex);
                }
            }

            return(output);
        }