예제 #1
0
        public static IEnumerable <Tuple <int, int, int> > DFSGraphNodesRecursive(GraphAdjacentLists <int> graph, int startNode,
                                                                                  HashSet <int> discoveredNodes = null, HashSet <int> processedNodes = null, int?timer = null)
        {
            if (!graph.HasVertex(startNode))
            {
                yield break;
            }

            var currentNode = startNode;

            if (discoveredNodes == null)
            {
                discoveredNodes = new HashSet <int>();
            }

            if (processedNodes == null)
            {
                processedNodes = new HashSet <int>();
            }

            if (!timer.HasValue)
            {
                timer = 0;
            }

            discoveredNodes.Add(currentNode);

            var entryTime = timer.Value;

            ++timer;

            foreach (var node in graph.GetAdjacentVertices(currentNode))
            {
                if (discoveredNodes.Contains(node))
                {
                    continue;
                }

                foreach (var subNode in DFSGraphNodesRecursive(graph, node, discoveredNodes, processedNodes, timer))
                {
                    yield return(subNode);
                }
            }

            processedNodes.Add(currentNode);
            ++timer;
            var exitTime = timer.Value;

            yield return(new Tuple <int, int, int>(startNode, entryTime, exitTime));
        }
예제 #2
0
        public static IEnumerable <string> DFSGraphEdgesRecursive(GraphAdjacentLists <int> graph, int startNode,
                                                                  HashSet <int> discoveredNodes     = null, HashSet <int> processedNodes = null,
                                                                  Dictionary <int, int> parentNodes = null, int parentNode               = -1)
        {
            if (!graph.HasVertex(startNode))
            {
                yield break;
            }

            var currentNode = startNode;

            if (discoveredNodes == null)
            {
                discoveredNodes = new HashSet <int>();
            }

            if (processedNodes == null)
            {
                processedNodes = new HashSet <int>();
            }

            if (parentNodes == null)
            {
                parentNodes = new Dictionary <int, int>();
            }

            parentNodes[currentNode] = parentNode;

            discoveredNodes.Add(currentNode);

            foreach (var node in graph.GetAdjacentVertices(currentNode))
            {
                if (processedNodes.Contains(node))
                {
                    if (graph.DirectedGraph == GraphAdjacentLists <int> .DirectedGraphEnum.Directed)
                    {
                        yield return("back edge: " + currentNode + "-" + node);
                    }
                    else
                    {
                        continue;
                    }
                }
                else if (discoveredNodes.Contains(node))
                {
                    if (parentNode == node)
                    {
                        continue;
                    }
                    else
                    {
                        yield return("back edge: " + currentNode + "-" + node);
                    }
                }
                else if (!discoveredNodes.Contains(node))
                {
                    parentNodes[node] = currentNode;
                    yield return("tree edge: " + currentNode + "-" + node);

                    foreach (var subEdge in DFSGraphEdgesRecursive(graph, node, discoveredNodes, processedNodes, parentNodes, currentNode))
                    {
                        yield return(subEdge);
                    }
                }
            }

            processedNodes.Add(currentNode);
        }