_left_rotate() in SBBT

Author: Kishan-Ved

pydatastructs/trees/_backend/cpp/SelfBalancingBinaryTree.hpp

@@ -88,7 +88,7 @@ static PyObject* SelfBalancingBinaryTree__right_rotate(SelfBalancingBinaryTree*
     PyObject* k = PyObject_GetItem(args, PyOne);
     BinaryTree* bt = self->bst->binary_tree;
     PyObject* y = reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(k)])->right;
-    if (y!=Py_None) {
+    if (y != Py_None) {
         reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(y)])->parent = j;
     }
     reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(j)])->left = y;
@@ -110,6 +110,33 @@ static PyObject* SelfBalancingBinaryTree__right_rotate(SelfBalancingBinaryTree*
     Py_RETURN_NONE;
 }
 
+static PyObject* SelfBalancingBinaryTree__left_rotate(SelfBalancingBinaryTree* self, PyObject *args) {
+    PyObject* j = PyObject_GetItem(args, PyZero);
+    PyObject* k = PyObject_GetItem(args, PyOne);
+    BinaryTree* bt = self->bst->binary_tree;
+    PyObject* y = reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(k)])->left;
+    if (y != Py_None) {
+        reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(y)])->parent = j;
+    }
+    reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(j)])->right = y;
+    reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(k)])->parent = reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(j)])->parent;
+    if (reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(k)])->parent != Py_None) {
+        if (reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(k)])->parent)])->left == j) {
+            reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(k)])->parent)])->left = k;
+        }
+        else {
+            reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(k)])->parent)])->right = k;
+        }
+    }
+    reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(j)])->parent = k;
+    reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(k)])->left = j;
+    PyObject* kp = reinterpret_cast<TreeNode*>(bt->tree->_one_dimensional_array->_data[PyLong_AsLong(k)])->parent;
+    if (kp == Py_None) {
+        bt->root_idx = k;
+    }
+    Py_RETURN_NONE;
+}
+
 static struct PyMethodDef SelfBalancingBinaryTree_PyMethodDef[] = {
     {"insert", (PyCFunction) SelfBalancingBinaryTree_insert, METH_VARARGS | METH_KEYWORDS, NULL},
     {"delete", (PyCFunction) SelfBalancingBinaryTree_delete, METH_VARARGS | METH_KEYWORDS, NULL},
@@ -123,6 +150,7 @@ static struct PyMethodDef SelfBalancingBinaryTree_PyMethodDef[] = {
     {"rank", (PyCFunction) SelfBalancingBinaryTree_rank, METH_VARARGS, NULL},
     {"select", (PyCFunction) SelfBalancingBinaryTree_select, METH_VARARGS, NULL},
     {"_right_rotate", (PyCFunction) SelfBalancingBinaryTree__right_rotate, METH_VARARGS, NULL},
+    {"_left_rotate", (PyCFunction) SelfBalancingBinaryTree__left_rotate, METH_VARARGS, NULL},
     {NULL}
 };
 

pydatastructs/trees/tests/test_binary_trees.py

@@ -436,11 +436,11 @@ def test_Treap():
     assert tree.search(2) == 1
     assert tree.delete(1) is None
 
-def test_SelfBalancingBinaryTree():
+def _test_SelfBalancingBinaryTree(backend):
     """
     https://github.com/codezonediitj/pydatastructs/issues/234
     """
-    tree = SelfBalancingBinaryTree(backend=Backend.CPP)
+    tree = SelfBalancingBinaryTree(backend=backend)
     tree.insert(5, 5)
     tree.insert(5.5, 5.5)
     tree.insert(4.5, 4.5)
@@ -456,20 +456,26 @@ def test_SelfBalancingBinaryTree():
     assert tree.tree[2].right != 3
     assert tree.tree[tree.tree[5].parent].right == 5
 
-    trav = BinaryTreeTraversal(tree, backend=Backend.CPP)
+    trav = BinaryTreeTraversal(tree, backend=backend)
     in_order = trav.depth_first_search(order='in_order')
     pre_order = trav.depth_first_search(order='pre_order')
     assert [node.key for node in in_order] == [4.4, 4.5, 4.55, 4.6, 4.65, 5, 5.5]
     assert [node.key for node in pre_order] == [5, 4.5, 4.4, 4.55, 4.6, 4.65, 5.5]
 
     assert tree.tree[tree.tree[3].parent].right == 3
-    # tree._left_rotate(5, 3)
-    # assert str(tree) == original_tree
-    # tree.insert(4.54, 4.54)
-    # tree.insert(4.56, 4.56)
-    # tree._left_rotate(5, 8)
-    # assert tree.tree[tree.tree[8].parent].left == 8
-# test_SelfBalancingBinaryTree()
+    tree._left_rotate(5, 3)
+    assert str(tree) == original_tree
+    tree.insert(4.54, 4.54)
+    tree.insert(4.56, 4.56)
+    tree._left_rotate(5, 8)
+    assert tree.tree[tree.tree[8].parent].left == 8
+
+def test_SelfBalancingBinaryTree():
+    _test_SelfBalancingBinaryTree(Backend.PYTHON)
+
+def test_cpp_SelfBalancingBinaryTree():
+    _test_SelfBalancingBinaryTree(Backend.CPP)
+
 def test_SplayTree():
     t = SplayTree(100, 100)
     t.insert(50, 50)