Added Sparse table data structure for RMQ

pydatastructs/miscellaneous_data_structures/__init__.py

@@ -4,7 +4,8 @@
     stack,
     binomial_trees,
     queue,
-    disjoint_set
+    disjoint_set,
+    sparse_table
 )
 
 from .binomial_trees import (
@@ -27,3 +28,8 @@
     DisjointSetForest,
 )
 __all__.extend(disjoint_set.__all__)
+
+from .sparse_table import (
+    SparseTable,
+)
+__all__.extend(sparse_table.__all__)

pydatastructs/miscellaneous_data_structures/algorithms.py

@@ -0,0 +1,32 @@
+from pydatastructs.miscellaneous_data_structures.sparse_table import SparseTable
+
+
+class RangeMinimumQuery:
+    def __new__(cls, array, ds='sparse_table'):
+        if ds == 'array':
+            pass
+        elif ds == 'sparse_table':
+            return RangeMinimumQuerySparseTable(cls)
+        else:
+            raise NotImplementedError(
+                "Currently %s data structure for range "
+                "minimum query isn't implemented yet."
+                % (ds))
+
+    def query(L, R):
+        raise NotImplementedError(
+            "This is an abstract method.")
+
+
+class RangeMinimumQuerySparseTable(RangeMinimumQuery):
+
+    __slots__ = ["sparse_table"]
+
+    def __new__(cls, array):
+        obj = object.__new__(cls)
+        sparse_table = SparseTable(array)
+        obj.sparse_table = sparse_table
+        return obj
+
+    def query(self, i, j):
+        return self.sparse_table.__rangequery__(i, j)

pydatastructs/miscellaneous_data_structures/sparse_table.py

@@ -0,0 +1,55 @@
+from pydatastructs.linear_data_structures.arrays import (
+    MultiDimensionalArray, OneDimensionalArray)
+from pydatastructs.utils.misc_util import NoneType
+import math
+
+__all__ = ['SparseTable']
+
+
+class SparseTable(object):
+    """
+    Represents a sparse table
+
+    References
+    ==========
+
+    .. [1] https://cp-algorithms.com/data_structures/sparse-table.html
+    """
+
+    __slots__ = ['table']
+
+    def __new__(cls, array, N=500000):
+        obj = object.__new__(cls)
+        MAXLOG = int(math.log2(2*N))
+
+    def __init__(self, array, N):
+        self.table = MultiDimensionalArray(int, 2*N+10, self.MAXLOG)
+        self.logs = OneDimensionalArray(int, 2*N+10)
+        self.logs[0] = self.logs[1] = 0
+        for i in range(2, N):
+            self.logs[i] = self.logs[int(i/2)] + 1
+
+    @classmethod
+    def methods(cls):
+        return ['__createtable__', '__rangequery__']
+
+    def _comp(x, y):
+        if(x < y):
+            return x
+        else:
+            return y
+
+    def __createtable__(self, arr, comp=_comp):
+        for i in range(len(arr)):
+            self.table[i][0] = arr[i]
+        for j in range(1, self.MAXLOG):
+            for i in range(len(arr) - (1 << j) + 1):
+                self.table[i][j] = comp(
+                    self.table[i][j-1],
+                    self.table[i+(1 << (j-1))][j-1])
+
+    def __rangequery__(self, L, R, comp=_comp):
+        j = self.logs[R-L+1]
+        return comp(
+            self.table[L][j],
+            self.table[R-(1 << j)+1][j])