Implemeted Treaps and CartesianTree

pydatastructs/trees/__init__.py

@@ -13,6 +13,8 @@
     BinaryTreeTraversal,
     AVLTree,
     BinaryIndexedTree,
+    CartesianTree,
+    Treap,
     SplayTree
 )
 __all__.extend(binary_trees.__all__)

pydatastructs/trees/binary_trees.py

@@ -1,17 +1,21 @@
-from pydatastructs.utils import TreeNode
+from pydatastructs.utils import TreeNode, CartesianTreeNode
 from pydatastructs.miscellaneous_data_structures import Stack
 from pydatastructs.linear_data_structures import (
     OneDimensionalArray, DynamicOneDimensionalArray)
 from pydatastructs.linear_data_structures.arrays import ArrayForTrees
 from collections import deque as Queue
+import random
 from copy import deepcopy
 
+
 __all__ = [
     'AVLTree',
     'BinaryTree',
     'BinarySearchTree',
     'BinaryTreeTraversal',
     'BinaryIndexedTree',
+    'CartesianTree',
+    'Treap',
     'SplayTree'
 ]
 
@@ -642,6 +646,143 @@ def _left_rotate(self, j, k):
         if kp is None:
             self.root_idx = k
 
+class CartesianTree(SelfBalancingBinaryTree):
+    """
+    Represents cartesian trees.
+
+    Examples
+    ========
+
+    >>> from pydatastructs.trees import CartesianTree as CT
+    >>> c = CT()
+    >>> c.insert(1, 4, 1)
+    >>> c.insert(2, 3, 2)
+    >>> child = c.tree[c.root_idx].left
+    >>> c.tree[child].data
+    1
+    >>> c.search(1)
+    0
+    >>> c.search(-1) is None
+    True
+    >>> c.delete(1) is True
+    True
+    >>> c.search(1) is None
+    True
+    >>> c.delete(2) is True
+    True
+    >>> c.search(2) is None
+    True
+
+    References
+    ==========
+
+    .. [1] https://www.cs.princeton.edu/courses/archive/spr09/cos423/Lectures/geo-st.pdf
+
+    See Also
+    ========
+
+    pydatastructs.trees.binary_tree.SelfBalancingBinaryTree
+    """
+    @classmethod
+    def methods(cls):
+        return ['__str__', 'insert', 'delete']
+
+    def _bubble_up(self, node_idx):
+        node = self.tree[node_idx]
+        parent_idx = self.tree[node_idx].parent
+        parent = self.tree[parent_idx]
+        while (node.parent is not None) and (parent.priority > node.priority):
+            if parent.right == node_idx:
+                self._left_rotate(parent_idx, node_idx)
+            else:
+                self._right_rotate(parent_idx, node_idx)
+            node = self.tree[node_idx]
+            parent_idx = self.tree[node_idx].parent
+            if parent_idx is not None:
+                parent = self.tree[parent_idx]
+        if node.parent is None:
+            self.tree[node_idx].is_root = True
+
+    def _trickle_down(self, node_idx):
+        node = self.tree[node_idx]
+        while node.left is not None or node.right is not None:
+            if node.left is None:
+                self._left_rotate(node_idx, self.tree[node_idx].right)
+            elif node.right is None:
+                self._right_rotate(node_idx, self.tree[node_idx].left)
+            elif self.tree[node.left].priority < self.tree[node.right].priority:
+                self._right_rotate(node_idx, self.tree[node_idx].left)
+            else:
+                self._left_rotate(node_idx, self.tree[node_idx].right)
+            node = self.tree[node_idx]
+
+    def insert(self, key, priority, data=None):
+        super(CartesianTree, self).insert(key, data)
+        node_idx = super(CartesianTree, self).search(key)
+        node = self.tree[node_idx]
+        new_node = CartesianTreeNode(key, priority, data)
+        new_node.parent = node.parent
+        new_node.left = node.left
+        new_node.right = node.right
+        self.tree[node_idx] = new_node
+        if node.is_root:
+            self.tree[node_idx].is_root = True
+        else:
+            self._bubble_up(node_idx)
+
+    def delete(self, key, **kwargs):
+        balancing_info = kwargs.get('balancing_info', False)
+        node_idx = super(CartesianTree, self).search(key)
+        if node_idx is not None:
+            self._trickle_down(node_idx)
+            return super(CartesianTree, self).delete(key, balancing_info = balancing_info)
+
+    def __str__(self):
+        to_be_printed = ['' for i in range(self.tree._last_pos_filled + 1)]
+        for i in range(self.tree._last_pos_filled + 1):
+            if self.tree[i] is not None:
+                node = self.tree[i]
+                to_be_printed[i] = (node.left, node.key, node.priority, node.data, node.right)
+        return str(to_be_printed)
+
+class Treap(CartesianTree):
+    """
+    Represents treaps.
+
+    Examples
+    ========
+
+    >>> from pydatastructs.trees import Treap as T
+    >>> t = T()
+    >>> t.insert(1, 1)
+    >>> t.insert(2, 2)
+    >>> t.search(1)
+    0
+    >>> t.search(-1) is None
+    True
+    >>> t.delete(1) is True
+    True
+    >>> t.search(1) is None
+    True
+    >>> t.delete(2) is True
+    True
+    >>> t.search(2) is None
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Treap
+
+    """
+    @classmethod
+    def methods(cls):
+        return ['insert']
+
+    def insert(self, key, data=None):
+        priority = random.random()
+        super(Treap, self).insert(key, priority, data)
+
 class AVLTree(SelfBalancingBinaryTree):
     """
     Represents AVL trees.

pydatastructs/trees/tests/test_binary_trees.py

@@ -1,9 +1,10 @@
 from pydatastructs.trees.binary_trees import (
     BinarySearchTree, BinaryTreeTraversal, AVLTree,
-    ArrayForTrees, BinaryIndexedTree, SelfBalancingBinaryTree, SplayTree)
+    ArrayForTrees, BinaryIndexedTree, SelfBalancingBinaryTree, SplayTree, CartesianTree, Treap)
 from pydatastructs.utils.raises_util import raises
 from pydatastructs.utils.misc_util import TreeNode
 from copy import deepcopy
+import random
 
 def test_BinarySearchTree():
     BST = BinarySearchTree
@@ -320,6 +321,59 @@ def test_BinaryIndexedTree():
     assert t.get_sum(0, 4) == 114
     assert t.get_sum(1, 9) == 54
 
+def test_CartesianTree():
+    tree = CartesianTree()
+    tree.insert(3, 1, 3)
+    tree.insert(1, 6, 1)
+    tree.insert(0, 9, 0)
+    tree.insert(5, 11, 5)
+    tree.insert(4, 14, 4)
+    tree.insert(9, 17, 9)
+    tree.insert(7, 22, 7)
+    tree.insert(6, 42, 6)
+    tree.insert(8, 49, 8)
+    tree.insert(2, 99, 2)
+    assert str(tree) == \
+           ("[(1, 3, 1, 3, 3), (2, 1, 6, 1, 9), "
+            "(None, 0, 9, 0, None), (4, 5, 11, 5, 5), "
+            "(None, 4, 14, 4, None), (6, 9, 17, 9, None), "
+            "(7, 7, 22, 7, 8), (None, 6, 42, 6, None), "
+            "(None, 8, 49, 8, None), (None, 2, 99, 2, None)]")
+    tree.insert(1.5, 4, 1.5)
+    assert str(tree) == \
+           ("[(10, 3, 1, 3, 3), (2, 1, 6, 1, None), "
+            "(None, 0, 9, 0, None), (4, 5, 11, 5, 5), "
+            "(None, 4, 14, 4, None), (6, 9, 17, 9, None), "
+            "(7, 7, 22, 7, 8), (None, 6, 42, 6, None), "
+            "(None, 8, 49, 8, None), (None, 2, 99, 2, None), "
+            "(1, 1.5, 4, 1.5, 9)]")
+    k = tree.search(1.5)
+    assert tree.tree[tree.tree[k].parent].key == 3
+    tree.delete(1.5)
+    tree.tree[tree.tree[tree.root_idx].left].key == 1
+    tree.delete(8)
+    assert tree.search(8) is None
+    tree.delete(7)
+    assert tree.search(7) is None
+    tree.delete(3)
+    assert tree.search(3) is None
+    assert tree.delete(18) is None
+
+def test_Treap():
+
+    random.seed(0)
+    tree = Treap()
+    tree.insert(7, 7)
+    tree.insert(2, 2)
+    tree.insert(3, 3)
+    tree.insert(4, 4)
+    tree.insert(5, 5)
+    assert isinstance(tree.tree[0].priority, float)
+    tree.delete(1)
+    assert tree.search(1) is None
+    assert tree.search(2) == 1
+    assert tree.delete(1) is None
+
 def test_issue_234():
     """
     https://github.com/codezonediitj/pydatastructs/issues/234

pydatastructs/utils/__init__.py

@@ -9,6 +9,7 @@
     AdjacencyListGraphNode,
     AdjacencyMatrixGraphNode,
     GraphEdge,
-    Set
+    Set,
+    CartesianTreeNode
 )
 __all__.extend(misc_util.__all__)

pydatastructs/utils/misc_util.py

@@ -6,7 +6,8 @@
     'AdjacencyListGraphNode',
     'AdjacencyMatrixGraphNode',
     'GraphEdge',
-    'Set'
+    'Set',
+    'CartesianTreeNode'
 ]
 
 _check_type = lambda a, t: isinstance(a, t)
@@ -56,6 +57,34 @@ def __str__(self):
         """
         return str((self.left, self.key, self.data, self.right))
 
+class CartesianTreeNode(TreeNode):
+    """
+    Represents node in cartesian trees.
+
+    Parameters
+    ==========
+
+    data
+        Any valid data to be stored in the node.
+    key
+        Required for comparison operations.
+    priority: int
+        An integer value for heap property.
+
+    """
+    __slots__ = ['key', 'data', 'priority']
+
+    def __new__(cls, key, priority, data=None):
+        obj = TreeNode.__new__(cls, key, data)
+        obj.priority = priority
+        return obj
+
+    def __str__(self):
+        """
+        Used for printing.
+        """
+        return str((self.left, self.key, self.priority, self.data, self.right))
+
 class BinomialTreeNode(TreeNode):
     """
     Represents node in binomial trees.

pydatastructs/utils/tests/test_code_quality.py

@@ -95,7 +95,8 @@ def _apis():
     pyds.miscellaneous_data_structures.stack.LinkedListStack,
     pyds.DisjointSetForest, pyds.BinomialTree, pyds.TreeNode, pyds.MAryTreeNode,
     pyds.LinkedListNode, pyds.BinomialTreeNode, pyds.AdjacencyListGraphNode,
-    pyds.AdjacencyMatrixGraphNode, pyds.GraphEdge, pyds.Set, pyds.BinaryIndexedTree]
+    pyds.AdjacencyMatrixGraphNode, pyds.GraphEdge, pyds.Set, pyds.BinaryIndexedTree,
+    pyds.CartesianTree, pyds.CartesianTreeNode, pyds.Treap]
 
 def test_public_api():
     pyds = pydatastructs

pydatastructs/utils/tests/test_misc_util.py

@@ -1,5 +1,5 @@
 from pydatastructs.utils import (AdjacencyListGraphNode, AdjacencyMatrixGraphNode,
-                                GraphEdge, BinomialTreeNode, MAryTreeNode)
+                                GraphEdge, BinomialTreeNode, MAryTreeNode, CartesianTreeNode)
 from pydatastructs.utils.raises_util import raises
 
 def test_AdjacencyListGraphNode():
@@ -38,3 +38,7 @@ def test_MAryTreeNode():
     m.add_children(*[i for i in range(2,10)])
     assert str(m) == "(1, 1)"
     assert str(m.children) == "['2', '3', '4', '5', '6', '7', '8', '9']"
+
+def test_CartesianTreeNode():
+    c = CartesianTreeNode(1, 1, 1)
+    assert str(c) == "(None, 1, 1, 1, None)"