Esempio n. 1
0
        /// <summary>
        /// Performs a BFT of the graph with the given visitor and starting at the given vertex number.
        /// </summary>
        /// <param name="visitor"></param>
        /// <param name="start"></param>
        public virtual void BreadthFirstTraversal(IPrePostVisitor visitor, int start)
        {
            bool[] flags = new bool[mNumberOfVertices];
            for (int i = 0; i < mNumberOfVertices; i++)
            {
                flags[i] = false;
            }
            IQueue queue = new QueueAsLinkedList();

            queue.Enqueue(vertex[start]);
            flags[start] = true;
            while (!(queue.IsEmpty || visitor.IsDone))
            {
                IVertex vertex1 = (IVertex)queue.Dequeue();
                visitor.PreVisit(vertex1);
                Console.WriteLine("being in " + vertex1.Number);
                IEnumerator iEnumerator = vertex1.Successors.GetEnumerator();
                try
                {
                    while (iEnumerator.MoveNext())
                    {
                        IVertex vertex2 = (IVertex)iEnumerator.Current;
                        if (!flags[vertex2.Number])
                        {
                            queue.Enqueue(vertex2);
                            visitor.Visit(vertex2);
                            Console.WriteLine("engueueing " + vertex2.Number);
                            flags[vertex2.Number] = true;
                        }
                    }
                }
                finally
                {
                    IDisposable iDisposable = iEnumerator as IDisposable;
                    if (iDisposable != null)
                    {
                        iDisposable.Dispose();
                    }
                }
                visitor.PostVisit(vertex1);
            }
        }
Esempio n. 2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="tree"></param>
        public static void BreadthFirstTraversal(ITree tree)
        {
            IQueue queue = new QueueAsLinkedList();

            if (!tree.IsEmpty)
            {
                queue.Enqueue(tree);
            }
            while (!queue.IsEmpty)
            {
                ITree tree2 = (ITree)queue.Dequeue();
                Console.WriteLine(tree2.Key);
                for (int i = 0; i < tree2.Degree; i++)
                {
                    ITree tree3 = tree2.GetSubtree(i);
                    if (!tree3.IsEmpty)
                    {
                        queue.Enqueue(tree3);
                    }
                }
            }
        }
Esempio n. 3
0
        /// <summary>
        /// Performs a BFT of the tree
        /// </summary>
        /// <param name="visitor"></param>
        public virtual void BreadthFirstTraversal(IVisitor visitor)
        {
            QueueAsLinkedList queue = new QueueAsLinkedList();

            if (!base.IsEmpty)
            {
                queue.Enqueue(this);
            }
            while (!queue.IsEmpty && !visitor.IsDone)
            {
                ITree tree1 = (ITree)queue.Dequeue();
                visitor.Visit(tree1.Key);
                for (int i = 0; i < tree1.Degree; i++)
                {
                    ITree tree2 = tree1.GetSubtree(i);
                    if (!tree2.IsEmpty)
                    {
                        queue.Enqueue(tree2);
                    }
                }
            }
        }
Esempio n. 4
0
        /// <summary>
        /// This traversal visits the nodes of a directed graph in the order specified by a topological sort.
        /// Informally, a topological sort is a list of the vertices of a (directed) graph in which all the successors
        ///  of any given vertex appear in the sequence after that vertex.
        /// </summary>
        /// <param name="visitor"></param>
        public virtual void TopologicalOrderTraversal(IVisitor visitor)
        {
            int[] nums1 = new int[(uint)mNumberOfVertices];
            for (int i1 = 0; i1 < mNumberOfVertices; i1++)
            {
                nums1[i1] = 0;
            }
            IEnumerator iEnumerator = Edges.GetEnumerator();

            try
            {
                while (iEnumerator.MoveNext())
                {
                    int[] nums2;

                    int k;

                    IVertex vertex1 = ((IEdge)iEnumerator.Current).V1;
                    (nums2 = nums1)[k = vertex1.Number]++;
                }
            }
            finally
            {
                IDisposable iDisposable = iEnumerator as IDisposable;
                if (iDisposable != null)
                {
                    iDisposable.Dispose();
                }
            }
            IQueue queue = new QueueAsLinkedList();
            // a cyclic graph might not have an entry point without in-edges
            //Thanks to Morton Mertner to fix this [email protected]
            int inEdges = 0;

            while (queue.IsEmpty || inEdges > mNumberOfEdges)
            {
                for (int j = 0; j < mNumberOfVertices; j++)
                {
                    bool selectionCriteria = nums1[j] == inEdges;
                    if (inEdges > 0)                      // cyclic graph - add nodes with cyclic refs first
                    {
                        foreach (IEdge e in vertex[j].EmanatingEdges)
                        {
                            selectionCriteria &= e.V0.Number == e.V1.Number;
                        }
                    }
                    if (selectionCriteria)
                    {
                        queue.Enqueue(vertex[j]);
                    }
                }
                inEdges++;
            }

            while (!(queue.IsEmpty || visitor.IsDone))
            {
                IVertex vertex2 = (IVertex)queue.Dequeue();
                visitor.Visit(vertex2);
                iEnumerator = vertex2.Successors.GetEnumerator();
                try
                {
                    while (iEnumerator.MoveNext())
                    {
                        int[] nums2;

                        int k;

                        IVertex vertex3 = (IVertex)iEnumerator.Current;
                        if ((nums2 = nums1)[k = vertex3.Number]-- == 0)
                        {
                            queue.Enqueue(vertex3);
                        }
                    }
                }
                catch (Exception exc)
                {
                    System.Diagnostics.Trace.WriteLine(exc.Message, "AbstractGraph.TopologicalOrderTraversal");
                }
                finally
                {
                    IDisposable iDisposable = iEnumerator as IDisposable;
                    if (iDisposable != null)
                    {
                        iDisposable.Dispose();
                    }
                }
            }
        }
 internal Enumerator(QueueAsLinkedList queue)
 {
     this.queue = queue;
 }