Пример #1
0
        public override void Traverse(int Source, ProcessEdge callback, PreProcessvertex preProcessVertex)
        {
            if (VertexState[Source] == State.Undiscovered)
            {
                VertexState[Source] = State.Discovered;
                time++;
                EntryTime[Source] = time;
                preProcessVertex(G, Source);

                foreach (Edge edge in G[Source])
                {
                    if (VertexState[edge.Y] == State.Undiscovered)
                    {
                        Parent[edge.Y] = Source;
                        callback(G, Source, edge);
                        Traverse(edge.Y, callback, preProcessVertex);
                    }
                    else if (VertexState[edge.Y] != State.Processed || G.IsDirected)
                    {
                        if (Parent[Source] != edge.Y)
                        {
                            callback(G, Source, edge);
                        }
                    }
                }
                VertexState[Source] = State.Processed;
                time++;
                ExitTime[Source] = time;
            }
        }
Пример #2
0
        public override void Traverse(int Source, ProcessEdge callback, PreProcessvertex preProcessVertex)
        {
            if (VertexState[Source] == State.Undiscovered)
            {
                Queue <int> queue = new Queue <int>();

                queue.Enqueue(Source);
                VertexState[Source] = State.Discovered;
                Parent[Source]      = -1;

                while (queue.Count > 0)
                {
                    int vertex = queue.Dequeue();
                    preProcessVertex(G, vertex);
                    foreach (Edge edge in G[vertex])
                    {
                        if (VertexState[edge.Y] != State.Processed || G.IsDirected)
                        {
                            callback(G, vertex, edge);
                        }

                        if (VertexState[edge.Y] == State.Undiscovered)
                        {
                            queue.Enqueue(edge.Y);
                            VertexState[edge.Y] = State.Discovered;
                            Parent[edge.Y]      = vertex;
                        }
                    }
                    VertexState[vertex] = State.Processed;
                }
            }
        }
Пример #3
0
        public override void Traverse(int Source, ProcessEdge callback, PreProcessvertex preProcessVertex)
        {
            if (VertexState[Source] == State.Undiscovered)
            {
                Queue<int> queue = new Queue<int>();

                queue.Enqueue(Source);
                VertexState[Source] = State.Discovered;
                Parent[Source] = -1;

                while (queue.Count > 0)
                {
                    int vertex = queue.Dequeue();
                    preProcessVertex(G, vertex);
                    foreach (Edge edge in G[vertex])
                    {
                        if (VertexState[edge.Y] != State.Processed || G.IsDirected)
                            callback(G, vertex, edge);

                        if (VertexState[edge.Y] == State.Undiscovered)
                        {
                            queue.Enqueue(edge.Y);
                            VertexState[edge.Y] = State.Discovered;
                            Parent[edge.Y] = vertex;
                        }
                    }
                    VertexState[vertex] = State.Processed;
                }
            }
        }
Пример #4
0
 public abstract void Traverse(int Source, ProcessEdge callback, PreProcessvertex preProcessVertex);
Пример #5
0
 public abstract void Traverse(int Source, ProcessEdge callback, PreProcessvertex preProcessVertex);
Пример #6
0
        public override void Traverse(int Source, ProcessEdge callback, PreProcessvertex preProcessVertex)
        {
            if (VertexState[Source] == State.Undiscovered)
            {
                VertexState[Source] = State.Discovered;
                time++;
                EntryTime[Source] = time;
                preProcessVertex(G, Source);

                foreach (Edge edge in G[Source])
                {
                    if (VertexState[edge.Y] == State.Undiscovered)
                    {
                        Parent[edge.Y] = Source;
                        callback(G, Source, edge);
                        Traverse(edge.Y, callback, preProcessVertex);
                    }
                    else if (VertexState[edge.Y] != State.Processed || G.IsDirected)
                        if (Parent[Source] != edge.Y)
                            callback(G, Source, edge);
                }
                VertexState[Source] = State.Processed;
                time++;
                ExitTime[Source] = time;
            }
        }