Updated FusionTree implementation to inherit from correct parent

Author: FamALouiz

docs/source/pydatastructs/trees/binary_trees.rst

@@ -18,5 +18,3 @@ Binary Trees
 .. autoclass:: pydatastructs.RedBlackTree
 
 .. autoclass:: pydatastructs.BinaryTreeTraversal
-
-.. autoclass:: pydatastructs.FusionTree

docs/source/pydatastructs/trees/m_ary_trees.rst

@@ -1,3 +1,4 @@
 M-ary Trees
 ===========
 
+.. autoclass:: pydatastructs.FusionTree

pydatastructs/trees/__init__.py

@@ -18,12 +18,13 @@
     Treap,
     SplayTree,
     RedBlackTree,
-    FusionTree
 )
 __all__.extend(binary_trees.__all__)
 
 from .m_ary_trees import (
-    MAryTreeNode, MAryTree
+    MAryTreeNode,
+    MAryTree,
+    FusionTree
 )
 
 __all__.extend(m_ary_trees.__all__)

pydatastructs/trees/binary_trees.py

@@ -1,5 +1,4 @@
 import random
-import math
 from collections import deque as Queue
 from pydatastructs.utils import TreeNode, CartesianTreeNode, RedBlackTreeNode
 from pydatastructs.miscellaneous_data_structures import Stack
@@ -19,7 +18,6 @@
     'Treap',
     'SplayTree',
     'RedBlackTree',
-    'FusionTree',
 ]
 
 class BinaryTree(object):
@@ -1889,160 +1887,3 @@ def get_sum(self, left_index, right_index):
                    self.get_prefix_sum(left_index - 1)
         else:
             return self.get_prefix_sum(right_index)
-
-class FusionTree(object):
-    """
-    Implements a Fusion Tree, a multi-way search tree optimized for integer keys.
-
-    Parameters
-    ==========
-
-    key: int
-        The integer key to insert.
-    root_data: Any
-        Optional data to store with the key.
-    backend: pydatastructs.Backend
-        The backend to be used. Available backends: Python and C++
-        Optional, by default, the Python backend is used. For faster execution, use the C++ backend.
-    word_size: int
-        The size of the integer keys in bits.
-        Optional, by default, set to 64.
-
-    Examples
-    ========
-
-    >>> from pydatastructs import FusionTree
-    >>> ft = FusionTree()
-    >>> ft.insert(1, 1)
-    >>> ft.insert(2, 2)
-    >>> ft.search(1)
-    0
-    >>> ft.delete(1)
-    True
-    >>> ft.search(1)
-
-
-    References:
-    - https://en.wikipedia.org/wiki/Fusion_tree
-    - Fredman & Willard (1990): "Fusion Trees"
-    """
-
-    __slots__ = ['root_idx', 'tree', 'size', 'B',
-                 'sketch_mask', 'fingerprint_multiplier']
-
-    def __new__(cls, key=None, root_data=None, **kwargs):
-        backend = kwargs.get('backend', Backend.PYTHON)
-        raise_if_backend_is_not_python(cls, backend)
-
-        obj = object.__new__(cls)
-        key = None if root_data is None else key
-        root = TreeNode(key, root_data)
-        root.is_root = True
-        obj.root_idx = 0
-        obj.tree, obj.size = ArrayForTrees(TreeNode, [root]), 1
-        obj.B = int(math.log2(kwargs.get('word_size', 64))
-                    ** (1/5))  # Multi-way branching factor
-        obj.sketch_mask = 0  # Computed dynamically
-        obj.fingerprint_multiplier = 2654435761  # Prime multiplier for fingerprinting
-        return obj
-
-    def _compute_sketch_mask(self):
-        """
-        Computes a sketch mask for efficient parallel comparisons.
-        """
-        keys = [node.key for node in self.tree if node is not None]
-        if len(keys) > 1:
-            significant_bits = [max(k.bit_length() for k in keys)]
-            self.sketch_mask = sum(1 << b for b in significant_bits)
-
-    def insert(self, key, data=None):
-        """
-        Inserts a key into the Fusion Tree.
-
-        Parameters
-        ==========
-
-        key: int
-            The integer key to insert.
-        data: Any
-            Optional data to store with the key.
-        """
-        # Edge case for root node if not intially inserted
-        if self.size == 1 and self.tree[0].key is None:
-            self.tree[0] = TreeNode(key, data)
-            self.tree[0].is_root = True
-            return
-
-        node = TreeNode(key, data)
-        self.tree.append(node)
-        self.size += 1
-        if self.size > 1:
-            self._compute_sketch_mask()
-
-    def _sketch_key(self, key):
-        """
-        Applies the sketch mask to compress the key for fast comparison.
-        """
-        return key & self.sketch_mask
-
-    def _fingerprint(self, key):
-        """
-        Uses multiplication-based fingerprinting to create a unique identifier
-        for the key, allowing fast parallel searches.
-        """
-        return (key * self.fingerprint_multiplier) & ((1 << 64) - 1)
-
-    def search(self, key):
-        """
-        Searches for a key in the Fusion Tree using bitwise sketching and fingerprinting.
-
-        Parameters
-        ==========
-
-        key: int
-            The integer key to search.
-
-        Returns
-        =======
-
-        int: The index of the key in the tree, or None if not found.
-        """
-        sketch = self._sketch_key(key)
-        fingerprint = self._fingerprint(key)
-        for i in range(self.size):
-            if self._sketch_key(self.tree[i].key) == sketch and self._fingerprint(self.tree[i].key) == fingerprint:
-                return i
-        return None
-
-    def delete(self, key):
-        """
-        Deletes a key from the Fusion Tree.
-
-        Parameters
-        ==========
-
-        key: int
-            The integer key to delete.
-
-        Returns
-        =======
-
-        bool: True if the key was successfully deleted, False otherwise.
-
-        """
-        index = self.search(key)
-        if index is not None:
-            self.tree[index] = None  # Soft delete
-            # Compact tree
-            self.tree = [node for node in self.tree if node is not None]
-            self.size -= 1
-            if self.size > 1:
-                self._compute_sketch_mask()
-            return True
-        return False
-
-    def __str__(self):
-        """
-        Returns a string representation of the Fusion Tree.
-        """
-        return str([(node.key, node.data) for node in self.tree if node is not None])

pydatastructs/trees/m_ary_trees.py

@@ -1,10 +1,12 @@
+import math
 from pydatastructs.utils import MAryTreeNode
 from pydatastructs.linear_data_structures.arrays import ArrayForTrees
 from pydatastructs.utils.misc_util import (
     Backend, raise_if_backend_is_not_python)
 
 __all__ = [
-    'MAryTree'
+    'MAryTree',
+    'FusionTree'
 ]
 
 class MAryTree(object):
@@ -170,3 +172,161 @@ def __str__(self):
                     if j is not None:
                         to_be_printed[i].append(j)
         return str(to_be_printed)
+
+
+class FusionTree(MAryTree):
+    """
+    Implements a Fusion Tree, a multi-way search tree optimized for integer keys.
+
+    Parameters
+    ==========
+
+    key: int
+        The integer key to insert.
+    root_data: Any
+        Optional data to store with the key.
+    backend: pydatastructs.Backend
+        The backend to be used. Available backends: Python and C++
+        Optional, by default, the Python backend is used. For faster execution, use the C++ backend.
+    word_size: int
+        The size of the integer keys in bits.
+        Optional, by default, set to 64.
+
+    Examples
+    ========
+
+    >>> from pydatastructs import FusionTree
+    >>> ft = FusionTree()
+    >>> ft.insert(1, 1)
+    >>> ft.insert(2, 2)
+    >>> ft.search(1)
+    0
+    >>> ft.delete(1)
+    True
+    >>> ft.search(1)
+
+
+    References:
+    - https://en.wikipedia.org/wiki/Fusion_tree
+    - Fredman & Willard (1990): "Fusion Trees"
+    """
+
+    __slots__ = ['root_idx', 'tree', 'size', 'B',
+                 'sketch_mask', 'fingerprint_multiplier']
+
+    def __new__(cls, key=None, root_data=None, **kwargs):
+        backend = kwargs.get('backend', Backend.PYTHON)
+        raise_if_backend_is_not_python(cls, backend)
+
+        obj = object.__new__(cls)
+        key = None if root_data is None else key
+        root = MAryTreeNode(key, root_data)
+        root.is_root = True
+        obj.root_idx = 0
+        obj.tree, obj.size = ArrayForTrees(MAryTreeNode, [root]), 1
+        obj.B = int(math.log2(kwargs.get('word_size', 64))
+                    ** (1/5))  # Multi-way branching factor
+        obj.sketch_mask = 0  # Computed dynamically
+        obj.fingerprint_multiplier = 2654435761  # Prime multiplier for fingerprinting
+        return obj
+
+    def _compute_sketch_mask(self):
+        """
+        Computes a sketch mask for efficient parallel comparisons.
+        """
+        keys = [node.key for node in self.tree if node is not None]
+        if len(keys) > 1:
+            significant_bits = [max(k.bit_length() for k in keys)]
+            self.sketch_mask = sum(1 << b for b in significant_bits)
+
+    def insert(self, key, data=None):
+        """
+        Inserts a key into the Fusion Tree.
+
+        Parameters
+        ==========
+
+        key: int
+            The integer key to insert.
+        data: Any
+            Optional data to store with the key.
+        """
+        # Edge case for root node if not intially inserted
+        if self.size == 1 and self.tree[0].key is None:
+            self.tree[0] = MAryTreeNode(key, data)
+            self.tree[0].is_root = True
+            return
+
+        node = MAryTreeNode(key, data)
+        self.tree.append(node)
+        self.size += 1
+        if self.size > 1:
+            self._compute_sketch_mask()
+
+    def _sketch_key(self, key):
+        """
+        Applies the sketch mask to compress the key for fast comparison.
+        """
+        return key & self.sketch_mask
+
+    def _fingerprint(self, key):
+        """
+        Uses multiplication-based fingerprinting to create a unique identifier
+        for the key, allowing fast parallel searches.
+        """
+        return (key * self.fingerprint_multiplier) & ((1 << 64) - 1)
+
+    def search(self, key):
+        """
+        Searches for a key in the Fusion Tree using bitwise sketching and fingerprinting.
+
+        Parameters
+        ==========
+
+        key: int
+            The integer key to search.
+
+        Returns
+        =======
+
+        int: The index of the key in the tree, or None if not found.
+        """
+        sketch = self._sketch_key(key)
+        fingerprint = self._fingerprint(key)
+        for i in range(self.size):
+            if self._sketch_key(self.tree[i].key) == sketch and self._fingerprint(self.tree[i].key) == fingerprint:
+                return i
+        return None
+
+    def delete(self, key):
+        """
+        Deletes a key from the Fusion Tree.
+
+        Parameters
+        ==========
+
+        key: int
+            The integer key to delete.
+
+        Returns
+        =======
+
+        bool: True if the key was successfully deleted, False otherwise.
+
+        """
+        index = self.search(key)
+        if index is not None:
+            self.tree[index] = None  # Soft delete
+            # Compact tree
+            self.tree = [node for node in self.tree if node is not None]
+            self.size -= 1
+            if self.size > 1:
+                self._compute_sketch_mask()
+            return True
+        return False
+
+    def __str__(self):
+        """
+        Returns a string representation of the Fusion Tree.
+        """
+        return str([(node.key, node.data) for node in self.tree if node is not None])