added preorder traversal and tested

Author: Kishan-Ved

pydatastructs/trees/_backend/cpp/BinaryTreeTraversal.hpp

@@ -6,6 +6,7 @@
 #include <structmember.h>
 #include <cstdlib>
 #include <iostream>
+#include <stack>
 #include "../../../utils/_backend/cpp/utils.hpp"
 #include "../../../utils/_backend/cpp/TreeNode.hpp"
 #include "../../../linear_data_structures/_backend/cpp/arrays/ArrayForTrees.hpp"
@@ -24,13 +25,14 @@ static void BinaryTreeTraversal_dealloc(BinaryTreeTraversal *self) {
 
 static PyObject* BinaryTreeTraversal___new__(PyTypeObject* type, PyObject *args, PyObject *kwds) {
     BinaryTreeTraversal *self;
+    self = reinterpret_cast<BinaryTreeTraversal*>(type->tp_alloc(type, 0));
+
     PyObject* tree = PyObject_GetItem(args, PyZero);
     if (PyType_Ready(&BinarySearchTreeType) < 0) { // This has to be present to finalize a type object. This should be called on all type objects to finish their initialization.
         return NULL;
     }
     if (PyObject_IsInstance(tree, (PyObject *)&BinarySearchTreeType)) {
         self->tree = reinterpret_cast<BinarySearchTree*>(tree)->binary_tree;
-        std::cout<<"here"<<std::endl;
     }
     else {
         PyErr_SetString(PyExc_ValueError, "Not a supported type for BinaryTreeTraversal.");
@@ -39,7 +41,31 @@ static PyObject* BinaryTreeTraversal___new__(PyTypeObject* type, PyObject *args,
     return reinterpret_cast<PyObject*>(self);
 }
 
+static PyObject* BinaryTreeTraversal__pre_order(BinaryTreeTraversal* self, PyObject *args){
+    PyObject* visit = PyList_New(0);
+    ArrayForTrees* tree = self->tree->tree;
+    long size = self->tree->size;
+    long node = PyLong_AsLong(PyObject_GetItem(args, PyZero));
+    std::stack<long> s;
+    s.push(node);
+
+    while (!s.empty()) {
+        node = s.top();
+        s.pop();
+        TreeNode* curr_node = reinterpret_cast<TreeNode*>(tree->_one_dimensional_array->_data[node]);
+        PyList_Append(visit, reinterpret_cast<PyObject*>(curr_node));
+        if (curr_node->right != Py_None) {
+            s.push(PyLong_AsLong(curr_node->right));
+        }
+        if (curr_node->left != Py_None) {
+            s.push(PyLong_AsLong(curr_node->left));
+        }
+    }
+    return visit;
+}
+
 static struct PyMethodDef BinaryTreeTraversal_PyMethodDef[] = {
+    {"_pre_order", (PyCFunction) BinaryTreeTraversal__pre_order, METH_VARARGS, NULL},
     {NULL}
 };
 

pydatastructs/trees/_backend/cpp/trees.cpp

@@ -1,6 +1,7 @@
 #include <Python.h>
 #include "BinaryTree.hpp"
 #include "BinarySearchTree.hpp"
+#include "BinaryTreeTraversal.hpp"
 
 static struct PyModuleDef trees_struct = {
     PyModuleDef_HEAD_INIT,
@@ -26,5 +27,11 @@ PyMODINIT_FUNC PyInit__trees(void) {
     Py_INCREF(&BinarySearchTreeType);
     PyModule_AddObject(trees, "BinarySearchTree", reinterpret_cast<PyObject*>(&BinarySearchTreeType));
 
+    if (PyType_Ready(&BinaryTreeTraversalType) < 0) {
+        return NULL;
+    }
+    Py_INCREF(&BinaryTreeTraversalType);
+    PyModule_AddObject(trees, "BinaryTreeTraversal", reinterpret_cast<PyObject*>(&BinaryTreeTraversalType));
+
     return trees;
 }

pydatastructs/trees/tests/test_binary_trees.py

@@ -60,6 +60,13 @@ def test_cpp_BST2():
     "(5, 6, 6, 6), (None, 4, 4, None), (None, 7, 7, None), (8, 14, 14, None), "
     "(None, 13, 13, None)]")
 
+    from pydatastructs.trees._backend.cpp import _trees
+    t = _trees.BinaryTreeTraversal(b)
+    p = t._pre_order(0)
+    assert [node.key for node in p] == [8, 3, 1, 6, 4, 7, 10, 14, 13]
+    # key_arr = [node.key for node in p]
+    # print(key_arr)
+
     ##### _simple_path() test #####
     path = b._simple_path(1,0)
     assert path[0] == 0
@@ -178,6 +185,7 @@ def test_cpp_BST2():
     assert b3.lower_bound(-1) == 7
     assert b3.lower_bound(20) is None
 
+test_cpp_BST2()
 
 def test_cpp_BST_speed():
     BST = BinarySearchTree
@@ -195,6 +203,18 @@ def test_cpp_BST_speed():
     print("Time taken by Python backend: ",t2-t1,"s")
     print("Time taken by C++ backend:    ",t4-t3,"s")
 
+# def test_cpp_BinaryTreeTraversal():
+#     BST = BinarySearchTree
+#     from pydatastructs.trees._backend.cpp import _trees
+#     b = BST(backend=Backend.CPP)
+#     for i in range(10,-1,-1):
+#         b.insert(i,i)
+#     t = _trees.BinaryTreeTraversal(b)
+#     p = t._pre_order(0)
+#     key_arr = [node.key for node in p]
+#     print(key_arr)
+
+# test_cpp_BinaryTreeTraversal()
 
 ################### Python Tests below ###################