コード例 #1
0
ファイル: AdjacencyGraphTest.cs プロジェクト: belzecue/Common
        public void PrimsMinimumSpanningTree()
        {
            var graph  = CreateCitiesGraph();
            var search = new AdjacencySearch(graph.VertexCount);

            graph.PrimsMinimumSpanningTree(search, 0, new AdjacencyEdgeComparer());

            int[] order = new int[] { 0, 1, 2, 3, 4, 10, 11, 5, 8, 9, 7, 6 };

            Assert.AreEqual(order.Length, search.Order.Count);

            for (int i = 0; i < order.Length; i++)
            {
                Assert.AreEqual(order[i], search.Order[i]);
            }
        }
コード例 #2
0
ファイル: AdjacencyGraphTest.cs プロジェクト: belzecue/Common
        public void BreadthFirstSearch()
        {
            var graph  = CreateCitiesGraph();
            var search = new AdjacencySearch(graph.VertexCount);

            graph.BreadthFirstSearch(search, 5);

            int[] order = new int[] { 5, 0, 3, 4, 6, 7, 1, 2, 8, 10, 9, 11 };

            Assert.AreEqual(order.Length, search.Order.Count);

            for (int i = 0; i < order.Length; i++)
            {
                Assert.AreEqual(order[i], search.Order[i]);
            }
        }
コード例 #3
0
        internal static void Search <VERTEX, EDGE>(AdjacencyGraph <VERTEX, EDGE> graph, AdjacencySearch search, int root)
            where EDGE : class, IAdjacencyEdge, new()
        {
            int count = graph.VertexCount;

            Queue <int> queue = new Queue <int>();

            queue.Enqueue(root);

            search.Parent[root] = root;

            bool[] isVisited = new bool[count];
            isVisited[root] = true;

            while (queue.Count != 0)
            {
                int u = queue.Dequeue();
                search.Order.Add(u);

                IList <EDGE> edges = graph.Edges[u];
                if (edges == null)
                {
                    continue;
                }

                for (int i = 0; i < edges.Count; i++)
                {
                    int to = edges[i].To;

                    if (isVisited[to])
                    {
                        continue;
                    }

                    queue.Enqueue(to);
                    search.Parent[to] = u;
                    isVisited[to]     = true;
                }
            }
        }
コード例 #4
0
        internal static void Search <VERTEX, EDGE>(AdjacencyGraph <VERTEX, EDGE> graph, AdjacencySearch search, int root, IComparer <EDGE> comparer)
            where EDGE : class, IAdjacencyEdge, new()
        {
            int count = graph.VertexCount;

            bool[] isVisited = new bool[count];
            isVisited[root] = true;

            search.Parent[root] = root;
            search.Order.Add(root);

            PriorityQueue <EDGE> queue = new PriorityQueue <EDGE>(comparer);

            if (graph.Edges[root] != null)
            {
                foreach (EDGE edge in graph.Edges[root])
                {
                    queue.Push(edge);
                }
            }

            while (queue.Count != 0)
            {
                EDGE edge = queue.Pop();

                int v = edge.To;
                if (isVisited[v])
                {
                    continue;
                }

                search.Order.Add(v);
                isVisited[v]     = true;
                search.Parent[v] = edge.From;

                if (graph.Edges[v] != null)
                {
                    foreach (EDGE e in graph.Edges[v])
                    {
                        if (isVisited[e.To])
                        {
                            continue;
                        }
                        queue.Push(e);
                    }
                }
            }
        }