improved the code quality

Kishan-Ved · Kishan-Ved · commit 654c49f1d2e7 · 2024-05-29T14:44:58.000+05:30
diff --git a/pydatastructs/trees/_backend/cpp/BinarySearchTree.hpp b/pydatastructs/trees/_backend/cpp/BinarySearchTree.hpp
@@ -115,7 +115,7 @@ static PyObject* BinarySearchTree_search(BinarySearchTree* self, PyObject* args,
         if (comp == 1) {
             walk = reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(walk)])->left;
         }
-        else{
+        else {
             walk = reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(walk)])->right;
         }
     }
@@ -124,7 +124,7 @@ static PyObject* BinarySearchTree_search(BinarySearchTree* self, PyObject* args,
     if (ret_parent==Py_None || PyLong_AsLong(ret_parent)==0) {
         return walk;
     }
-    else{
+    else {
         return Py_BuildValue("OO",walk,parent);
     }
     Py_RETURN_NONE; // dummy return statement, never executed
@@ -188,7 +188,7 @@ static PyObject* BinarySearchTree_insert(BinarySearchTree* self, PyObject* args)
             prev_node = reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(walk)])->right;
             walk = reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(walk)])->right;
         }
-        else{
+        else {
             if (reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(walk)])->left == Py_None) {
                 new_node->parent = prev_node;
                 ArrayForTrees_append(bt->tree, Py_BuildValue( "[O]", reinterpret_cast<PyObject*>(new_node)) );
@@ -229,12 +229,12 @@ static PyObject* BinarySearchTree_delete(BinarySearchTree* self, PyObject *args,
             reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(bt->root_idx)])->data = Py_None;
             reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(bt->root_idx)])->key = Py_None;
         }
-        else{
+        else {
             if (reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(parent)])->left == walk) {
                 Py_INCREF(Py_None);
                 reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(parent)])->left = Py_None;
             }
-            else{
+            else {
                 Py_INCREF(Py_None);
                 reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(parent)])->right = Py_None;
             }
@@ -472,7 +472,7 @@ static PyObject* BinarySearchTree__lca_2(BinarySearchTree* self, PyObject* args)
     PyObject* curr_root = bt->root_idx;
     PyObject* u = BinarySearchTree_search(self, Py_BuildValue("(O)",j), PyDict_New());
     PyObject* v = BinarySearchTree_search(self, Py_BuildValue("(O)",k), PyDict_New());
-    // std::cout<<PyLong_AsLong(u)<<" "<<PyLong_AsLong(v)<<std::endl;
+
     if (u==Py_None || v==Py_None) {
         PyErr_SetString(PyExc_ValueError, "One of the nodes doesn't exist.");
         return NULL;
@@ -503,35 +503,26 @@ static PyObject* BinarySearchTree__lca_2(BinarySearchTree* self, PyObject* args)
         return NULL;
     }
     long long v_left = PyLong_AsLongLong(cres2);
-    // std::cout<<"h1"<<std::endl;
 
     while (!(u_left ^ v_left)) {
         if (u_left && v_left) {
             curr_root = reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(curr_root)])->left;
-            // std::cout<<"curr_root chagned to: "<<PyLong_AsLong(curr_root)<<std::endl;
         }
         else {
             curr_root = reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(curr_root)])->right;
         }
-        // std::cout<<"h2"<<std::endl;
 
         if (curr_root == u || curr_root == v) {
             if (curr_root == Py_None) {
                 Py_RETURN_NONE;
             }
             return reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(curr_root)])->key;
         }
-        // std::cout<<"curr_root "<<PyLong_AsLong(curr_root)<<std::endl;
-
-        if (curr_root == Py_None || u == Py_None) {
-            // std::cout<<"here"<<std::endl;
-        }
 
         if (!PyCallable_Check(bt->comparator)) {
             PyErr_SetString(PyExc_ValueError, "comparator should be callable");
             return NULL;
         }
-        // std::cout<<"comp: "<<PyLong_AsLong(reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(u)])->key)<<" "<<PyLong_AsLong(reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(curr_root)])->key)<<std::endl;
         PyObject* arguments1 = Py_BuildValue("OO", reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(u)])->key, reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(curr_root)])->key);
         PyObject* cres1 = PyObject_CallObject(bt->comparator, arguments1);
         Py_DECREF(arguments1);
@@ -540,7 +531,6 @@ static PyObject* BinarySearchTree__lca_2(BinarySearchTree* self, PyObject* args)
             return NULL;
         }
         u_left = PyLong_AsLongLong(cres1);
-        // std::cout<<u_left<<std::endl;
 
         if (!PyCallable_Check(bt->comparator)) {
             PyErr_SetString(PyExc_ValueError, "comparator should be callable");
@@ -554,9 +544,7 @@ static PyObject* BinarySearchTree__lca_2(BinarySearchTree* self, PyObject* args)
             return NULL;
         }
         v_left = PyLong_AsLongLong(cres2);
-        // std::cout<<u_left<<" "<<v_left<<std::endl;
     }
-    // std::cout<<"h4"<<std::endl;
 
     if (curr_root == Py_None) {
         Py_RETURN_NONE;
diff --git a/pydatastructs/trees/_backend/cpp/BinaryTree.hpp b/pydatastructs/trees/_backend/cpp/BinaryTree.hpp
@@ -114,7 +114,7 @@ static PyObject* BinaryTree___str__(BinaryTree *self) {
             Py_INCREF(out);
             PyList_SET_ITEM(list, i, out);
         }
-        else{
+        else {
             PyObject* empty_string = PyUnicode_FromString("");
             PyList_SET_ITEM(list, i, empty_string);
         }
diff --git a/pydatastructs/trees/binary_trees.py b/pydatastructs/trees/binary_trees.py
@@ -386,7 +386,6 @@ def delete(self, key, **kwargs):
             return None
         if self.tree[walk].left is None and \
             self.tree[walk].right is None:
-            # print("here 1")
             if parent is None:
                 self.tree[self.root_idx].data = None
                 self.tree[self.root_idx].key = None
@@ -406,7 +405,6 @@ def delete(self, key, **kwargs):
 
         elif self.tree[walk].left is not None and \
             self.tree[walk].right is not None:
-            # print("here 2")
             twalk = self.tree[walk].right
             par = walk
             flag = False
@@ -433,7 +431,6 @@ def delete(self, key, **kwargs):
             self._update_size(a)
 
         else:
-            # print("here 3")
             if self.tree[walk].left is not None:
                 child = self.tree[walk].left
             else:
@@ -609,7 +606,6 @@ def _lca_1(self, j, k):
     def _lca_2(self, j, k):
         curr_root = self.root_idx
         u, v = self.search(j), self.search(k)
-        print(u)
         if (u is None) or (v is None):
             raise ValueError("One of the nodes with key %s "
                              "or %s doesn't exits"%(j, k))
@@ -621,21 +617,17 @@ def _lca_2(self, j, k):
         while not (u_left ^ v_left):
             if u_left and v_left:
                 curr_root = self.tree[curr_root].left
-                # print("curr_root changed to: ", curr_root)
             else:
                 curr_root = self.tree[curr_root].right
 
             if curr_root == u or curr_root == v:
                 if curr_root is None:
                     return None
                 return self.tree[curr_root].key
-            # print(curr_root)
-            # print(self.tree[u].key, self.tree[curr_root].key)
             u_left = self.comparator(self.tree[u].key, \
                 self.tree[curr_root].key)
             v_left = self.comparator(self.tree[v].key, \
                 self.tree[curr_root].key)
-            # print(u_left, v_left)
 
         if curr_root is None:
             return curr_root

Original file line number	Diff line number	Diff line change
`@@ -115,7 +115,7 @@ static PyObject* BinarySearchTree_search(BinarySearchTree* self, PyObject* args,`
`115`	`115`	`if (comp == 1) {`
`116`	`116`	`walk = reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(walk)])->left;`
`117`	`117`	`}`
`118`		`- else{`
	`118`	`+ else {`
`119`	`119`	`walk = reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(walk)])->right;`
`120`	`120`	`}`
`121`	`121`	`}`
`@@ -124,7 +124,7 @@ static PyObject* BinarySearchTree_search(BinarySearchTree* self, PyObject* args,`
`124`	`124`	`if (ret_parent==Py_None \|\| PyLong_AsLong(ret_parent)==0) {`
`125`	`125`	`return walk;`
`126`	`126`	`}`
`127`		`- else{`
	`127`	`+ else {`
`128`	`128`	`return Py_BuildValue("OO",walk,parent);`
`129`	`129`	`}`
`130`	`130`	`Py_RETURN_NONE; // dummy return statement, never executed`
`@@ -188,7 +188,7 @@ static PyObject* BinarySearchTree_insert(BinarySearchTree* self, PyObject* args)`
`188`	`188`	`prev_node = reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(walk)])->right;`
`189`	`189`	`walk = reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(walk)])->right;`
`190`	`190`	`}`
`191`		`- else{`
	`191`	`+ else {`
`192`	`192`	`if (reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(walk)])->left == Py_None) {`
`193`	`193`	`new_node->parent = prev_node;`
`194`	`194`	`ArrayForTrees_append(bt->tree, Py_BuildValue( "[O]", reinterpret_cast<PyObject*>(new_node)) );`
`@@ -229,12 +229,12 @@ static PyObject* BinarySearchTree_delete(BinarySearchTree* self, PyObject *args,`
`229`	`229`	`reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(bt->root_idx)])->data = Py_None;`
`230`	`230`	`reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(bt->root_idx)])->key = Py_None;`
`231`	`231`	`}`
`232`		`- else{`
	`232`	`+ else {`
`233`	`233`	`if (reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(parent)])->left == walk) {`
`234`	`234`	`Py_INCREF(Py_None);`
`235`	`235`	`reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(parent)])->left = Py_None;`
`236`	`236`	`}`
`237`		`- else{`
	`237`	`+ else {`
`238`	`238`	`Py_INCREF(Py_None);`
`239`	`239`	`reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(parent)])->right = Py_None;`
`240`	`240`	`}`
`@@ -472,7 +472,7 @@ static PyObject* BinarySearchTree__lca_2(BinarySearchTree* self, PyObject* args)`
`472`	`472`	`PyObject* curr_root = bt->root_idx;`
`473`	`473`	`PyObject* u = BinarySearchTree_search(self, Py_BuildValue("(O)",j), PyDict_New());`
`474`	`474`	`PyObject* v = BinarySearchTree_search(self, Py_BuildValue("(O)",k), PyDict_New());`
`475`		`- // std::cout<<PyLong_AsLong(u)<<" "<<PyLong_AsLong(v)<<std::endl;`
	`475`	`+`
`476`	`476`	`if (u==Py_None \|\| v==Py_None) {`
`477`	`477`	`PyErr_SetString(PyExc_ValueError, "One of the nodes doesn't exist.");`
`478`	`478`	`return NULL;`
`@@ -503,35 +503,26 @@ static PyObject* BinarySearchTree__lca_2(BinarySearchTree* self, PyObject* args)`
`503`	`503`	`return NULL;`
`504`	`504`	`}`
`505`	`505`	`long long v_left = PyLong_AsLongLong(cres2);`
`506`		`- // std::cout<<"h1"<<std::endl;`
`507`	`506`
`508`	`507`	`while (!(u_left ^ v_left)) {`
`509`	`508`	`if (u_left && v_left) {`
`510`	`509`	`curr_root = reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(curr_root)])->left;`
`511`		`- // std::cout<<"curr_root chagned to: "<<PyLong_AsLong(curr_root)<<std::endl;`
`512`	`510`	`}`
`513`	`511`	`else {`
`514`	`512`	`curr_root = reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(curr_root)])->right;`
`515`	`513`	`}`
`516`		`- // std::cout<<"h2"<<std::endl;`
`517`	`514`
`518`	`515`	`if (curr_root == u \|\| curr_root == v) {`
`519`	`516`	`if (curr_root == Py_None) {`
`520`	`517`	`Py_RETURN_NONE;`
`521`	`518`	`}`
`522`	`519`	`return reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(curr_root)])->key;`
`523`	`520`	`}`
`524`		`- // std::cout<<"curr_root "<<PyLong_AsLong(curr_root)<<std::endl;`
`525`		`-`
`526`		`- if (curr_root == Py_None \|\| u == Py_None) {`
`527`		`- // std::cout<<"here"<<std::endl;`
`528`		`- }`
`529`	`521`
`530`	`522`	`if (!PyCallable_Check(bt->comparator)) {`
`531`	`523`	`PyErr_SetString(PyExc_ValueError, "comparator should be callable");`
`532`	`524`	`return NULL;`
`533`	`525`	`}`
`534`		`- // std::cout<<"comp: "<<PyLong_AsLong(reinterpret_cast<TreeNode>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(u)])->key)<<" "<<PyLong_AsLong(reinterpret_cast<TreeNode>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(curr_root)])->key)<<std::endl;`
`535`	`526`	`PyObject* arguments1 = Py_BuildValue("OO", reinterpret_cast<TreeNode>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(u)])->key, reinterpret_cast<TreeNode>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(curr_root)])->key);`
`536`	`527`	`PyObject* cres1 = PyObject_CallObject(bt->comparator, arguments1);`
`537`	`528`	`Py_DECREF(arguments1);`
`@@ -540,7 +531,6 @@ static PyObject* BinarySearchTree__lca_2(BinarySearchTree* self, PyObject* args)`
`540`	`531`	`return NULL;`
`541`	`532`	`}`
`542`	`533`	`u_left = PyLong_AsLongLong(cres1);`
`543`		`- // std::cout<<u_left<<std::endl;`
`544`	`534`
`545`	`535`	`if (!PyCallable_Check(bt->comparator)) {`
`546`	`536`	`PyErr_SetString(PyExc_ValueError, "comparator should be callable");`
`@@ -554,9 +544,7 @@ static PyObject* BinarySearchTree__lca_2(BinarySearchTree* self, PyObject* args)`
`554`	`544`	`return NULL;`
`555`	`545`	`}`
`556`	`546`	`v_left = PyLong_AsLongLong(cres2);`
`557`		`- // std::cout<<u_left<<" "<<v_left<<std::endl;`
`558`	`547`	`}`
`559`		`- // std::cout<<"h4"<<std::endl;`
`560`	`548`
`561`	`549`	`if (curr_root == Py_None) {`
`562`	`550`	`Py_RETURN_NONE;`
Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,7 @@ static PyObject* BinaryTree___str__(BinaryTree *self) {`
`114`	`114`	`Py_INCREF(out);`
`115`	`115`	`PyList_SET_ITEM(list, i, out);`
`116`	`116`	`}`
`117`		`- else{`
	`117`	`+ else {`
`118`	`118`	`PyObject* empty_string = PyUnicode_FromString("");`
`119`	`119`	`PyList_SET_ITEM(list, i, empty_string);`
`120`	`120`	`}`