bfs complete

Prerak Singh · Prerak Singh · commit 4df209759806 · 2025-06-19T20:42:25.000+05:30
diff --git a/pydatastructs/graphs/_backend/cpp/AdjacencyList.hpp b/pydatastructs/graphs/_backend/cpp/AdjacencyList.hpp
@@ -349,7 +349,7 @@ static PyMethodDef AdjacencyListGraph_methods[] = {
 };
 
 
-PyTypeObject AdjacencyListGraphType = {
+inline PyTypeObject AdjacencyListGraphType = {
     PyVarObject_HEAD_INIT(NULL, 0)                 // ob_base
     "_graph.AdjacencyListGraph",                   // tp_name
     sizeof(AdjacencyListGraph),                    // tp_basicsize
diff --git a/pydatastructs/graphs/_backend/cpp/AdjacencyMatrix.hpp b/pydatastructs/graphs/_backend/cpp/AdjacencyMatrix.hpp
@@ -236,7 +236,7 @@ static PyMethodDef AdjacencyMatrixGraph_methods[] = {
     {NULL}
 };
 
-PyTypeObject AdjacencyMatrixGraphType = {
+inline PyTypeObject AdjacencyMatrixGraphType = {
     PyVarObject_HEAD_INIT(NULL, 0)                  // ob_base
     "_graph.AdjacencyMatrixGraph",                  // tp_name
     sizeof(AdjacencyMatrixGraph),                   // tp_basicsize
diff --git a/pydatastructs/graphs/_backend/cpp/Algorithms.hpp b/pydatastructs/graphs/_backend/cpp/Algorithms.hpp
@@ -2,153 +2,154 @@
 #include <unordered_map>
 #include <queue>
 #include <string>
+#include <unordered_set>
 #include "AdjacencyList.hpp"
+#include "AdjacencyMatrix.hpp"
+
+
+static PyObject* breadth_first_search_adjacency_list(PyObject* self, PyObject* args, PyObject* kwargs) {
+    PyObject* graph_obj;
+    const char* source_name;
+    PyObject* operation;
+    PyObject* varargs = nullptr;
+    PyObject* kwargs_dict = nullptr;
+
+    static const char* kwlist[] = {"graph", "source_node", "operation", "args", "kwargs", nullptr};
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!sO|OO", const_cast<char**>(kwlist),
+                                     &AdjacencyListGraphType, &graph_obj,
+                                     &source_name, &operation,
+                                     &varargs, &kwargs_dict)) {
+        return nullptr;
+    }
 
-static inline AdjacencyListGraphNode* get_node(AdjacencyListGraph* graph, const std::string& name) {
-    auto it = graph->node_map.find(name);
-    return (it != graph->node_map.end()) ? it->second : nullptr;
-}
+    AdjacencyListGraph* cpp_graph = reinterpret_cast<AdjacencyListGraph*>(graph_obj);
 
-static PyObject* bfs_adjacency_list(PyObject* self, PyObject* args, PyObject* kwds) {
-    static char* kwlist[] = {(char*)"graph", (char*)"source_node", (char*)"operation", (char*)"extra_arg", NULL};
+    auto it = cpp_graph->node_map.find(source_name);
+    AdjacencyListGraphNode* start_node = it->second;
 
-    PyObject* py_graph = nullptr;
-    const char* source_node = nullptr;
-    PyObject* operation = nullptr;
-    PyObject* extra_arg = nullptr;
+    std::unordered_set<std::string> visited;
+    std::queue<AdjacencyListGraphNode*> q;
 
-    fprintf(stderr, "[bfs] Parsing arguments...\n");
+    q.push(start_node);
+    visited.insert(start_node->name);
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "OsO|O", kwlist,
-                                     &py_graph, &source_node, &operation, &extra_arg)) {
-        fprintf(stderr, "[bfs] Failed to parse arguments\n");
-        return NULL;
-    }
+    while (!q.empty()) {
+    AdjacencyListGraphNode* node = q.front();
+    q.pop();
+
+    for (const auto& [adj_name, adj_obj] : node->adjacent) {
+        if (visited.count(adj_name)) continue;
+        if (!PyObject_IsInstance(adj_obj, (PyObject*)&AdjacencyListGraphNodeType)) continue;
+
+        AdjacencyListGraphNode* adj_node = reinterpret_cast<AdjacencyListGraphNode*>(adj_obj);
+
+        PyObject* base_args = PyTuple_Pack(2,
+                                           reinterpret_cast<PyObject*>(node),
+                                           reinterpret_cast<PyObject*>(adj_node));
+        if (!base_args)
+            return nullptr;
+
+        PyObject* final_args;
+        if (varargs && PyTuple_Check(varargs)) {
+            final_args = PySequence_Concat(base_args, varargs);
+            Py_DECREF(base_args);
+            if (!final_args)
+                return nullptr;
+        } else {
+            final_args = base_args;
+        }
 
-    fprintf(stderr, "[bfs] Arguments parsed:\n");
-    fprintf(stderr, "  - source_node: %s\n", source_node);
-    fprintf(stderr, "  - extra_arg: %s\n", (extra_arg ? Py_TYPE(extra_arg)->tp_name : "NULL"));
-    fprintf(stderr, "[bfs] Checking type of py_graph...\n");
-    fprintf(stderr, "        - Expected: %s\n", AdjacencyListGraphType.tp_name);
-    fprintf(stderr, "        - Actual:   %s\n", Py_TYPE(py_graph)->tp_name);
-    fprintf(stderr, "        - Expected address: %p\n", &AdjacencyListGraphType);
-    fprintf(stderr, "        - Actual type addr: %p\n", (void*)Py_TYPE(py_graph));
-
-    fprintf(stderr, "[bfs] Attempting to import _graph...\n");
-    PyObject* graph_module = PyImport_ImportModule("_graph");
-    if (!graph_module) {
-    PyErr_Print();
-    PyErr_SetString(PyExc_ImportError, "Could not import _graph module");
-    return NULL;
-    }
+        PyObject* result = PyObject_Call(operation, final_args, kwargs_dict);
+        Py_DECREF(final_args);
 
-    PyObject* expected_type = PyObject_GetAttrString(graph_module, "AdjacencyListGraph");
-    Py_DECREF(graph_module);
+        if (!result)
+            return nullptr;
 
-    if (!expected_type || !PyType_Check(expected_type)) {
-        Py_XDECREF(expected_type);
-        PyErr_SetString(PyExc_TypeError, "Could not retrieve AdjacencyListGraph type");
-        return NULL;
-    }
+        Py_DECREF(result);
 
-    if (!PyObject_IsInstance(py_graph, expected_type)) {
-        Py_DECREF(expected_type);
-        PyErr_SetString(PyExc_TypeError, "Expected an AdjacencyListGraph instance");
-        return NULL;
+        visited.insert(adj_name);
+        q.push(adj_node);
     }
-
-    if (!PyCallable_Check(operation)) {
-        PyErr_SetString(PyExc_TypeError, "Expected a callable for operation");
-        fprintf(stderr, "[bfs] operation is not callable\n");
-        return NULL;
+    }
+    if (PyErr_Occurred()) {
+        return nullptr;
     }
 
-    AdjacencyListGraph* graph = (AdjacencyListGraph*)py_graph;
+    Py_RETURN_NONE;
+}
 
-    if (!get_node(graph, source_node)) {
-        PyErr_SetString(PyExc_ValueError, "Source node does not exist in the graph");
-        fprintf(stderr, "[bfs] source_node not found in graph\n");
-        return NULL;
+static PyObject* breadth_first_search_adjacency_matrix(PyObject* self, PyObject* args, PyObject* kwargs) {
+    PyObject* graph_obj;
+    const char* source_name;
+    PyObject* operation;
+    PyObject* varargs = nullptr;
+    PyObject* kwargs_dict = nullptr;
+
+    static const char* kwlist[] = {"graph", "source_node", "operation", "args", "kwargs", nullptr};
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!sO|OO", const_cast<char**>(kwlist),
+                                     &AdjacencyMatrixGraphType, &graph_obj,
+                                     &source_name, &operation,
+                                     &varargs, &kwargs_dict)) {
+        return nullptr;
     }
 
-    fprintf(stderr, "[bfs] Starting BFS from node: %s\n", source_node);
+    AdjacencyMatrixGraph* cpp_graph = reinterpret_cast<AdjacencyMatrixGraph*>(graph_obj);
+
+    auto it = cpp_graph->node_map.find(source_name);
+    if (it == cpp_graph->node_map.end()) {
+        PyErr_SetString(PyExc_KeyError, "Source node not found in graph");
+        return nullptr;
+    }
+    AdjacencyMatrixGraphNode* start_node = it->second;
 
-    std::unordered_map<std::string, bool> visited;
-    std::queue<std::string> q;
+    std::unordered_set<std::string> visited;
+    std::queue<AdjacencyMatrixGraphNode*> q;
 
-    q.push(source_node);
-    visited[source_node] = true;
+    q.push(start_node);
+    visited.insert(source_name);
 
     while (!q.empty()) {
-        std::string curr = q.front();
+        AdjacencyMatrixGraphNode* node = q.front();
         q.pop();
 
-        fprintf(stderr, "[bfs] Visiting node: %s\n", curr.c_str());
+        std::string node_name = reinterpret_cast<GraphNode*>(node)->name;
+        auto& neighbors = cpp_graph->matrix[node_name];
 
-        auto* curr_node = get_node(graph, curr);
-        if (!curr_node) {
-            fprintf(stderr, "[bfs] Warning: node %s not found in node_map\n", curr.c_str());
-            continue;
-        }
-
-        const auto& neighbors = curr_node->adjacent;
-
-        if (!neighbors.empty()) {
-            for (const auto& [next_name, _] : neighbors) {
-                if (!visited[next_name]) {
-                    fprintf(stderr, "[bfs] Considering neighbor: %s\n", next_name.c_str());
-
-                    PyObject* result = nullptr;
+        for (const auto& [adj_name, connected] : neighbors) {
+            if (!connected || visited.count(adj_name)) continue;
 
-                    if (extra_arg)
-                        result = PyObject_CallFunction(operation, "ssO", curr.c_str(), next_name.c_str(), extra_arg);
-                    else
-                        result = PyObject_CallFunction(operation, "ss", curr.c_str(), next_name.c_str());
+            auto adj_it = cpp_graph->node_map.find(adj_name);
+            if (adj_it == cpp_graph->node_map.end()) continue;
 
-                    if (!result) {
-                        fprintf(stderr, "[bfs] PyObject_CallFunction failed on (%s, %s)\n", curr.c_str(), next_name.c_str());
-                        PyErr_Print();
-                        return NULL;
-                    }
+            AdjacencyMatrixGraphNode* adj_node = adj_it->second;
 
-                    int keep_going = PyObject_IsTrue(result);
-                    Py_DECREF(result);
+            PyObject* base_args = PyTuple_Pack(2,
+                                               reinterpret_cast<PyObject*>(node),
+                                               reinterpret_cast<PyObject*>(adj_node));
+            if (!base_args) return nullptr;
 
-                    if (!keep_going) {
-                        fprintf(stderr, "[bfs] Operation requested to stop traversal at edge (%s -> %s)\n", curr.c_str(), next_name.c_str());
-                        Py_RETURN_NONE;
-                    }
-
-                    visited[next_name] = true;
-                    q.push(next_name);
-                }
+            PyObject* final_args;
+            if (varargs && PyTuple_Check(varargs)) {
+                final_args = PySequence_Concat(base_args, varargs);
+                Py_DECREF(base_args);
+                if (!final_args) return nullptr;
+            } else {
+                final_args = base_args;
             }
-        } else {
-            fprintf(stderr, "[bfs] Leaf node reached: %s\n", curr.c_str());
-
-            PyObject* result = nullptr;
 
-            if (extra_arg)
-                result = PyObject_CallFunction(operation, "sO", curr.c_str(), extra_arg);
-            else
-                result = PyObject_CallFunction(operation, "s", curr.c_str());
-
-            if (!result) {
-                fprintf(stderr, "[bfs] PyObject_CallFunction failed at leaf node (%s)\n", curr.c_str());
-                PyErr_Print();
-                return NULL;
-            }
-
-            int keep_going = PyObject_IsTrue(result);
+            PyObject* result = PyObject_Call(operation, final_args, kwargs_dict);
+            Py_DECREF(final_args);
+            if (!result) return nullptr;
             Py_DECREF(result);
 
-            if (!keep_going) {
-                fprintf(stderr, "[bfs] Operation requested to stop traversal at leaf node %s\n", curr.c_str());
-                Py_RETURN_NONE;
-            }
+            visited.insert(adj_name);
+            q.push(adj_node);
         }
     }
 
-    fprintf(stderr, "[bfs] BFS traversal complete\n");
+    if (PyErr_Occurred()) {
+        return nullptr;
+    }
+
     Py_RETURN_NONE;
 }
diff --git a/pydatastructs/graphs/_backend/cpp/algorithms.cpp b/pydatastructs/graphs/_backend/cpp/algorithms.cpp
@@ -1,34 +1,11 @@
 #include <Python.h>
 #include "Algorithms.hpp"
-
-static PyTypeObject* get_adjacency_list_graph_type() {
-    static PyTypeObject* cached_type = nullptr;
-
-    if (cached_type != nullptr) return cached_type;
-
-    PyObject* graph_mod = PyImport_ImportModule("pydatastructs.graphs._backend.cpp._graph");
-    if (!graph_mod) {
-        PyErr_SetString(PyExc_ImportError, "[algorithms] Failed to import _graph module");
-        return nullptr;
-    }
-
-    PyObject* type_obj = PyObject_GetAttrString(graph_mod, "AdjacencyListGraph");
-    Py_DECREF(graph_mod);
-
-    if (!type_obj || !PyType_Check(type_obj)) {
-        Py_XDECREF(type_obj);
-        PyErr_SetString(PyExc_TypeError, "[algorithms] AdjacencyListGraph is not a type object");
-        return nullptr;
-    }
-
-    cached_type = reinterpret_cast<PyTypeObject*>(type_obj);
-    return cached_type;
-}
-
-extern PyTypeObject* get_adjacency_list_graph_type();
+#include "AdjacencyList.hpp"
+#include "AdjacencyMatrix.hpp"
 
 static PyMethodDef AlgorithmsMethods[] = {
-    {"bfs_adjacency_list", (PyCFunction)bfs_adjacency_list, METH_VARARGS | METH_KEYWORDS, "Run BFS with callback"},
+    {"bfs_adjacency_list", (PyCFunction)breadth_first_search_adjacency_list, METH_VARARGS | METH_KEYWORDS, "Run BFS on adjacency list with callback"},
+    {"bfs_adjacency_matrix", (PyCFunction)breadth_first_search_adjacency_matrix, METH_VARARGS | METH_KEYWORDS, "Run BFS on adjacency matrix with callback"},
     {NULL, NULL, 0, NULL}
 };
 
@@ -38,9 +15,5 @@ static struct PyModuleDef algorithms_module = {
 };
 
 PyMODINIT_FUNC PyInit__algorithms(void) {
-    PyObject* graph_mod = PyImport_ImportModule("pydatastructs.graphs._backend.cpp._graph");
-    if (!graph_mod) return nullptr;
-    Py_DECREF(graph_mod);
-
     return PyModule_Create(&algorithms_module);
 }
diff --git a/pydatastructs/graphs/_backend/cpp/graph.cpp b/pydatastructs/graphs/_backend/cpp/graph.cpp
@@ -6,7 +6,15 @@
 #include "AdjacencyMatrixGraphNode.hpp"
 #include "graph_bindings.hpp"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
 
+PyMODINIT_FUNC PyInit__graph(void);
+
+#ifdef __cplusplus
+}
+#endif
 
 static struct PyModuleDef graph_module = {
     PyModuleDef_HEAD_INIT,
diff --git a/pydatastructs/graphs/algorithms.py b/pydatastructs/graphs/algorithms.py
@@ -94,8 +94,11 @@ def breadth_first_search(
             graph, source_node, operation, *args, **kwargs)
     else:
         if (graph._impl == "adjacency_list"):
-            extra_arg = args[0] if args else None
-            return _algorithms.bfs_adjacency_list(graph,source_node, operation, extra_arg)
+            extra_args = args if args else ()
+            return _algorithms.bfs_adjacency_list(graph, source_node, operation, extra_args)
+        if (graph._impl == "adjacency_matrix"):
+            extra_args = args if args else ()
+            return _algorithms.bfs_adjacency_matrix(graph, source_node, operation, extra_args)
 
 def _breadth_first_search_adjacency_list(
     graph, source_node, operation, *args, **kwargs):
diff --git a/pydatastructs/graphs/tests/test_algorithms.py b/pydatastructs/graphs/tests/test_algorithms.py
