def FirstPlot():
    algo_name = "BFS search"
    input_data = []
    exec_time = []
    for n in range(100, 1100, 100):
        graphList = []
        graph = BFS.Graph(g=graphList)
        vertexList = []
        BFS.createGraph(graph, vertexList, n)
        vertexNum = random.randint(0, n - 1)
        start_time = time.clock()
        BFS.BFS(graph, vertexList[vertexNum])
        end_time = time.clock()
        exec_time.append((end_time - start_time) * 1000)
        input_data.append(n)

    CreatePlot(input_data, exec_time, algo_name)
Example #2
0
    def test_BFS(self):
        """! Testing of BFS Method """
        g1 = BFS.Graph(False)
        g1.add_edge((0, 1))
        g1.add_edge((0, 2))
        g1.add_edge((1, 2))
        g1.add_edge((2, 0))
        g1.add_edge((2, 3))
        self.assertEqual(g1.BFS(0), [0, 1, 2, 3])

        g2 = BFS.Graph(True)
        g2.add_edge((0, 1))
        g2.add_edge((1, 2))
        g2.add_edge((2, 3))
        g2.add_edge((3, 4))
        g2.add_edge((4, 0))
        self.assertEqual(g2.BFS(0), [0, 1, 2, 3, 4])

        g3 = BFS.Graph(True)
        g3.add_edge((0, 1))
        g3.add_edge((1, 0))
        g3.add_edge((0, 2))
        g3.add_edge((2, 0))
        g3.add_edge((1, 2))
        g3.add_edge((2, 1))
        g3.add_edge((2, 3))
        g3.add_edge((3, 2))
        self.assertEqual(g3.BFS(0), [0, 1, 2, 3])

        g4 = BFS.Graph(False)
        g4.add_edge((0, 1))
        g4.add_edge((0, 2))
        g4.add_edge((0, 3))
        g4.add_edge((0, 4))
        g4.add_edge((1, 3))
        g4.add_edge((2, 5))
        self.assertEqual(g4.BFS(0), [0, 1, 2, 3, 4, 5])

        g5 = BFS.Graph(False)
        g5.add_edge((0, 2))
        g5.add_edge((6, 3))
        g5.add_edge((6, 2))
        g5.add_edge((4, 5))
        g5.add_edge((6, 5))
        g5.add_edge((4, 1))
        self.assertEqual(g5.BFS(0), [0, 2, 6, 3, 5, 4, 1])

        g6 = BFS.Graph(False)
        g6.add_edge((0, 1))
        g6.add_edge((0, 2))
        g6.add_edge((0, 3))
        g6.add_edge((0, 4))
        g6.add_edge((0, 5))
        g6.add_edge((0, 6))
        g6.add_edge((1, 6))
        g6.add_edge((6, 5))
        g6.add_edge((5, 4))
        g6.add_edge((4, 3))
        g6.add_edge((3, 2))
        g6.add_edge((2, 1))
        self.assertEqual(g6.BFS(0), [0, 1, 2, 3, 4, 5, 6])
Example #3
0
    def test_eq(self):
        """! Testing of __eq__ Method """
        g1 = BFS.Graph(False)
        g1.add_edge((0, 1))
        g1.add_edge((0, 2))
        g1.add_edge((1, 2))
        g1.add_edge((2, 0))
        g1.add_edge((2, 3))

        g2 = BFS.Graph(False)
        g2.add_edge((0, 1))
        g2.add_edge((0, 2))
        g2.add_edge((1, 2))
        g2.add_edge((2, 0))
        g2.add_edge((2, 3))
        self.assertEqual(True, g1 == g2)

        g3 = BFS.Graph(True)
        g3.add_edge((0, 1))
        g3.add_edge((1, 2))
        g3.add_edge((2, 3))
        g3.add_edge((3, 4))
        g3.add_edge((4, 0))

        g4 = BFS.Graph(True)
        g4.add_edge((0, 1))
        g4.add_edge((1, 2))
        g4.add_edge((2, 3))
        g4.add_edge((3, 4))
        g4.add_edge((4, 0))
        self.assertEqual(True, g3 == g4)

        g5 = BFS.Graph(True)
        g5.add_edge((0, 1))
        g5.add_edge((1, 0))
        g5.add_edge((0, 2))
        g5.add_edge((2, 0))
        g5.add_edge((1, 2))
        g5.add_edge((2, 1))
        g5.add_edge((2, 3))
        g5.add_edge((3, 2))

        g6 = BFS.Graph(True)
        g6.add_edge((0, 1))
        g6.add_edge((1, 0))
        g6.add_edge((0, 2))
        g6.add_edge((2, 0))
        g6.add_edge((1, 2))
        g6.add_edge((2, 1))
        g6.add_edge((2, 3))
        g6.add_edge((3, 2))
        self.assertEqual(True, g5 == g6)

        g7 = BFS.Graph(False)
        g7.add_edge((0, 1))
        g7.add_edge((0, 2))
        g7.add_edge((0, 3))
        g7.add_edge((0, 4))
        g7.add_edge((1, 3))
        g7.add_edge((2, 5))

        g8 = BFS.Graph(False)
        g8.add_edge((0, 1))
        g8.add_edge((0, 2))
        g8.add_edge((0, 3))
        g8.add_edge((0, 4))
        g8.add_edge((1, 3))
        g8.add_edge((2, 5))
        self.assertEqual(True, g7 == g8)

        g9 = BFS.Graph(False)
        g9.add_edge((0, 2))
        g9.add_edge((6, 3))
        g9.add_edge((6, 2))
        g9.add_edge((4, 5))
        g9.add_edge((6, 5))
        g9.add_edge((4, 1))

        g10 = BFS.Graph(False)
        g10.add_edge((0, 2))
        g10.add_edge((6, 3))
        g10.add_edge((6, 2))
        g10.add_edge((4, 5))
        g10.add_edge((6, 5))
        g10.add_edge((4, 1))
        self.assertEqual(True, g9 == g10)

        g11 = BFS.Graph(False)
        g11.add_edge((0, 1))
        g11.add_edge((0, 2))
        g11.add_edge((0, 3))
        g11.add_edge((0, 4))
        g11.add_edge((0, 5))
        g11.add_edge((0, 6))
        g11.add_edge((1, 6))
        g11.add_edge((6, 5))
        g11.add_edge((5, 4))
        g11.add_edge((4, 3))
        g11.add_edge((3, 2))
        g11.add_edge((2, 1))

        g12 = BFS.Graph(False)
        g12.add_edge((0, 1))
        g12.add_edge((0, 2))
        g12.add_edge((0, 3))
        g12.add_edge((0, 4))
        g12.add_edge((0, 5))
        g12.add_edge((0, 6))
        g12.add_edge((1, 6))
        g12.add_edge((6, 5))
        g12.add_edge((5, 4))
        g12.add_edge((4, 3))
        g12.add_edge((3, 2))
        g12.add_edge((2, 1))
        self.assertEqual(True, g11 == g12)