public void TestDoubleBreadthA_1()
        {
            SimpleGraph <int>    graph = GetGraphB();
            List <Vertex <int> > list  = graph.BreadthFirstSearch(2, 5);
            List <Vertex <int> > list2 = graph.BreadthFirstSearch(3, 8);
            List <Vertex <int> > list3 = graph.BreadthFirstSearch(1, 5);

            int[] array  = new int[] { 2, 0, 4, 5 };
            int[] array3 = new int[] { 1, 9, 5 };

            int index = 0;

            foreach (Vertex <int> vert in list)
            {
                Assert.AreEqual(array[index++], vert.Value);
            }

            Assert.AreEqual(0, list2.Count);

            index = 0;
            foreach (Vertex <int> vert in list3)
            {
                Assert.AreEqual(array3[index++], vert.Value);
            }
        }
        public void TestBreadthA_Empty()
        {
            SimpleGraph <int>    graph = GetGraphA();
            List <Vertex <int> > list  = graph.BreadthFirstSearch(7, 8);

            Assert.AreEqual(0, list.Count);
        }
Esempio n. 3
0
        public void BreadthFirstSearch_5_Vertex_Where_path_has_2v()
        {
            int size = 5;
            SimpleGraph <int> testGraph = new SimpleGraph <int>(size);

            testGraph.AddVertex(0); // добавляем вершины
            testGraph.AddVertex(10);
            testGraph.AddVertex(20);
            testGraph.AddVertex(30);
            testGraph.AddVertex(40);

            testGraph.AddEdge(0, 1); // добавление рёбер между вершинами
            testGraph.AddEdge(0, 3);
            testGraph.AddEdge(0, 4);

            testGraph.AddEdge(1, 2);
            testGraph.AddEdge(2, 3);
            testGraph.AddEdge(3, 4);

            List <Vertex <int> > vList = testGraph.BreadthFirstSearch(0, 4); // попытка построения пути из 0 (0) в 4 (40).

            vList.ForEach((item) => Console.Write(" {0}", item.Value));

            Assert.IsNotNull(vList);
            Assert.IsTrue(vList.Count == 2);
        }
Esempio n. 4
0
        public void BreadthFirstSearch_12_Vertex_14_Edges()
        {
            int size = 12;
            SimpleGraph <int> testGraph = new SimpleGraph <int>(size);

            testGraph.AddVertex(0); // добавляем вершины
            testGraph.AddVertex(10);
            testGraph.AddVertex(20);
            testGraph.AddVertex(30);
            testGraph.AddVertex(40);
            testGraph.AddVertex(50);
            testGraph.AddVertex(60);
            testGraph.AddVertex(70);
            testGraph.AddVertex(80);
            testGraph.AddVertex(90);
            testGraph.AddVertex(100);
            testGraph.AddVertex(110);

            testGraph.AddEdge(0, 1); // добавление рёбер между вершинами
            testGraph.AddEdge(0, 2);
            testGraph.AddEdge(0, 3);
            testGraph.AddEdge(1, 4);
            testGraph.AddEdge(2, 4);

            testGraph.AddEdge(2, 6);
            testGraph.AddEdge(3, 6);
            testGraph.AddEdge(4, 5);
            testGraph.AddEdge(5, 6);

            testGraph.AddEdge(7, 8);
            testGraph.AddEdge(7, 10);
            testGraph.AddEdge(8, 9);
            testGraph.AddEdge(10, 11);
            testGraph.AddEdge(9, 11);

            List <Vertex <int> > vList  = testGraph.BreadthFirstSearch(7, 9); // попытка построения пути из 70 в 90.
            List <Vertex <int> > vList2 = testGraph.BreadthFirstSearch(4, 3); // попытка построения пути из 40 в 30.

            vList.ForEach((item) => Console.Write(" {0}", item.Value));
            Console.WriteLine();
            vList2.ForEach((item) => Console.Write(" {0}", item.Value));

            Assert.IsNotNull(vList);
            Assert.IsTrue(vList.Count == 3);
            Assert.IsTrue(vList2.Count == 4);
        }
Esempio n. 5
0
        public void BreadthFirstSearch_13_Vertex_20_Edges()
        {
            int size = 13;
            SimpleGraph <int> testGraph = new SimpleGraph <int>(size);

            testGraph.AddVertex(0); // добавляем вершины
            testGraph.AddVertex(10);
            testGraph.AddVertex(20);
            testGraph.AddVertex(30);
            testGraph.AddVertex(40);
            testGraph.AddVertex(50);
            testGraph.AddVertex(60);
            testGraph.AddVertex(70);
            testGraph.AddVertex(80);
            testGraph.AddVertex(90);
            testGraph.AddVertex(100);
            testGraph.AddVertex(110);
            testGraph.AddVertex(120);

            testGraph.AddEdge(0, 1); // добавление рёбер между вершинами
            testGraph.AddEdge(0, 2);
            testGraph.AddEdge(0, 3);
            testGraph.AddEdge(1, 4);
            testGraph.AddEdge(1, 5);

            testGraph.AddEdge(1, 6);
            testGraph.AddEdge(2, 6);
            testGraph.AddEdge(3, 6);
            testGraph.AddEdge(3, 7);
            testGraph.AddEdge(3, 8);

            testGraph.AddEdge(4, 10);
            testGraph.AddEdge(5, 10);
            testGraph.AddEdge(6, 10);
            testGraph.AddEdge(6, 9);
            testGraph.AddEdge(6, 12);

            testGraph.AddEdge(7, 12);
            testGraph.AddEdge(8, 12);
            testGraph.AddEdge(9, 11);
            testGraph.AddEdge(10, 11);
            testGraph.AddEdge(11, 12);

            //List<Vertex<int>> vList = testGraph.BreadthFirstSearch(3, 10); // попытка построения пути из 30 в 100.
            //List<Vertex<int>> vList = testGraph.BreadthFirstSearch(9, 12); // попытка построения пути из 90 в 120.
            //List<Vertex<int>> vList = testGraph.BreadthFirstSearch(9, 11); // попытка построения пути из 90 в 110.
            //List<Vertex<int>> vList = testGraph.BreadthFirstSearch(12, 5); // попытка построения пути из 120 в 50.
            List <Vertex <int> > vList = testGraph.BreadthFirstSearch(5, 12); // попытка построения пути из 50 в 120.

            Console.WriteLine("Путь : ");
            vList.ForEach((item) => Console.Write(" {0}", item.Value));

            Assert.IsNotNull(vList);
            Assert.IsTrue(vList.Count == 4);
        }
Esempio n. 6
0
        public void TestBreadthFirstSearch()
        {
            var result = _graph.BreadthFirstSearch(1, 2);

            Assert.AreEqual(3, result.Count);
            var ethalon = new int[] { 2, 1, 3 };

            for (int i = 0; i < result.Count; i++)
            {
                Assert.AreEqual(ethalon[i], result[i].Value);
            }
        }
        public void TestBreadthB_1()
        {
            SimpleGraph <int>    graph = GetGraphB();
            List <Vertex <int> > list  = graph.BreadthFirstSearch(4, 9);

            int[] array = new int[] { 4, 5, 9 };
            int   index = 0;

            foreach (Vertex <int> vert in list)
            {
                Assert.AreEqual(array[index++], vert.Value);
            }
        }
        public void TestBreadthA_3()
        {
            SimpleGraph <int>    graph = GetGraphA();
            List <Vertex <int> > list  = graph.BreadthFirstSearch(6, 2);

            int[] array = new int[] { 6, 4, 0, 2 };
            int   index = 0;

            foreach (Vertex <int> vert in list)
            {
                Assert.AreEqual(array[index++], vert.Value);
            }
        }
Esempio n. 9
0
        // TODO: граничные случаи
        public static void Main(string[] args)
        {
            var g = new SimpleGraph <int>(9);

            g.AddVertex(0);
            g.AddVertex(1);
            g.AddVertex(2);
            g.AddVertex(3);
            g.AddVertex(4);
            g.AddVertex(5);
            g.AddVertex(6);
            g.AddVertex(7);
            g.AddVertex(8);

            g.AddEdge(0, 1);
            g.AddEdge(0, 2);
            g.AddEdge(0, 3);
            g.AddEdge(0, 4);

            g.AddEdge(1, 0);
            g.AddEdge(1, 2);
            g.AddEdge(1, 6);

            g.AddEdge(2, 1);
            g.AddEdge(2, 0);
            g.AddEdge(2, 3);

            g.AddEdge(3, 2);
            g.AddEdge(3, 0);
            g.AddEdge(3, 4);
            g.AddEdge(3, 7);

            g.AddEdge(4, 0);
            g.AddEdge(4, 3);
            g.AddEdge(4, 5);

            g.AddEdge(5, 4);
            g.AddEdge(5, 6);
            g.AddEdge(5, 7);

            g.AddEdge(6, 1);
            g.AddEdge(6, 5);

            g.AddEdge(7, 5);
            g.AddEdge(7, 3);

            var result = g.BreadthFirstSearch(1, 5);

            Console.WriteLine(result);
        }
Esempio n. 10
0
        public void BreadthFirstSearch_6_Vertex_where_1v_is_Closured()
        {
            int size = 6;
            SimpleGraph <int> testGraph = new SimpleGraph <int>(size);

            testGraph.AddVertex(0); // добавляем вершины
            testGraph.AddVertex(10);
            testGraph.AddVertex(20);
            testGraph.AddVertex(30);
            testGraph.AddVertex(40);
            testGraph.AddVertex(50);

            testGraph.AddEdge(0, 1); // добавление рёбер между вершинами
            testGraph.AddEdge(0, 2);
            testGraph.AddEdge(0, 3);
            testGraph.AddEdge(1, 3);
            testGraph.AddEdge(1, 4);

            testGraph.AddEdge(2, 3);
            testGraph.AddEdge(3, 3);
            testGraph.AddEdge(3, 4);
            testGraph.AddEdge(4, 5);

            List <Vertex <int> > vList = testGraph.BreadthFirstSearch(3, 5); // попытка построения пути из 30 в 50.
            //Console.WriteLine("Путь 3 -> 5: ");
            //vList.ForEach((item) => Console.Write(" {0}", item.Value));

            List <Vertex <int> > vList2 = testGraph.BreadthFirstSearch(2, 5); // попытка построения пути из 20 в 50.

            //Console.WriteLine("Путь 2 -> 5: ");
            //vList2.ForEach((item) => Console.Write(" {0}", item.Value));

            Assert.IsNotNull(vList);
            Assert.IsNotNull(vList2);
            Assert.IsTrue(vList.Count == 3);
            Assert.IsTrue(vList2.Count == 4);
        }
        public void TestFirstSilly_1()
        {
            SimpleGraph <int> graph = new SimpleGraph <int>(5);

            graph.AddVertex(1);
            graph.AddVertex(2);
            graph.AddVertex(3);
            graph.AddVertex(4);
            graph.AddVertex(5);

            graph.AddEdge(0, 1);
            graph.AddEdge(0, 4);
            graph.AddEdge(1, 2);
            graph.AddEdge(2, 3);
            graph.AddEdge(3, 4);

            List <Vertex <int> > list = graph.BreadthFirstSearch(0, 4);
        }
Esempio n. 12
0
        public void BreadthFirstSearch_12_Vertex_where_3_Path()
        {
            int size = 12;
            SimpleGraph <int> testGraph = new SimpleGraph <int>(size);

            testGraph.AddVertex(0); // добавляем вершины
            testGraph.AddVertex(10);
            testGraph.AddVertex(20);
            testGraph.AddVertex(30);
            testGraph.AddVertex(40);
            testGraph.AddVertex(50);
            testGraph.AddVertex(60);
            testGraph.AddVertex(70);
            testGraph.AddVertex(80);
            testGraph.AddVertex(90);
            testGraph.AddVertex(100);
            testGraph.AddVertex(110);

            testGraph.AddEdge(0, 1); // добавление рёбер между вершинами
            testGraph.AddEdge(0, 2);
            testGraph.AddEdge(0, 3);

            testGraph.AddEdge(1, 4);
            testGraph.AddEdge(2, 5);
            testGraph.AddEdge(3, 6);

            testGraph.AddEdge(4, 7);
            testGraph.AddEdge(5, 8);
            testGraph.AddEdge(6, 9);

            testGraph.AddEdge(7, 10);
            testGraph.AddEdge(8, 10);
            testGraph.AddEdge(8, 11);
            testGraph.AddEdge(9, 11);

            List <Vertex <int> > vList = testGraph.BreadthFirstSearch(0, 8); // попытка построения пути из 0 (0) в 8 (80).

            Console.Write("Путь : ");
            vList.ForEach((item) => Console.Write(" {0}", item.Value));

            Assert.IsNotNull(vList);
            Assert.IsTrue(vList.Count == 4);
        }
Esempio n. 13
0
        public void BreadthFirstSearch_10_Vertex_Where_Path_is_not_Exists()
        {
            int size = 10;
            SimpleGraph <int> testGraph = new SimpleGraph <int>(size);

            testGraph.AddVertex(0); // добавляем вершины
            testGraph.AddVertex(10);
            testGraph.AddVertex(20);
            testGraph.AddVertex(30);
            testGraph.AddVertex(40);
            testGraph.AddVertex(50);
            testGraph.AddVertex(60);
            testGraph.AddVertex(70);
            testGraph.AddVertex(80);

            testGraph.AddVertex(90); // ребро без связей

            testGraph.AddEdge(0, 1); // добавление рёбер между вершинами
            testGraph.AddEdge(0, 2);
            testGraph.AddEdge(0, 3);

            testGraph.AddEdge(1, 4);
            testGraph.AddEdge(2, 5);
            testGraph.AddEdge(3, 6);

            testGraph.AddEdge(4, 7);
            testGraph.AddEdge(5, 7);
            testGraph.AddEdge(5, 8);

            testGraph.AddEdge(6, 8);

            List <Vertex <int> > vList = testGraph.BreadthFirstSearch(0, 9); // попытка построения пути из 0 (0) в  9 (90).

            vList.ForEach((item) => Console.Write(" {0}", item.Value));

            Assert.IsNotNull(vList);
            Assert.IsTrue(vList.Count == 0);
        }