Added Longest Increasing Subsequence

pydatastructs/linear_data_structures/__init__.py

@@ -32,6 +32,7 @@
     bucket_sort,
     cocktail_shaker_sort,
     quick_sort,
-    longest_common_subsequence
+    longest_common_subsequence,
+    longest_increasing_subsequence
 )
 __all__.extend(algorithms.__all__)

pydatastructs/linear_data_structures/algorithms.py

@@ -14,7 +14,8 @@
     'bucket_sort',
     'cocktail_shaker_sort',
     'quick_sort',
-    'longest_common_subsequence'
+    'longest_common_subsequence',
+    'longest_increasing_subsequence'
 ]
 
 def _merge(array, sl, el, sr, er, end, comp):
@@ -787,3 +788,65 @@ def longest_common_subsequence(seq1: OneDimensionalArray, seq2: OneDimensionalAr
                     check_mat[i][j] = check_mat[i][j-1]
 
     return OneDimensionalArray(seq1._dtype, check_mat[row][col][-1])
+
+def longest_increasing_subsequence(seq: OneDimensionalArray) -> int:
+    """
+    Finds the length of longest increasing subsequence of the given sequences.
+    Parameters
+    ========
+    seq: OneDimensionalArray
+        The sequence.
+    Returns
+    =======
+    output: int
+        The length of longest increasing subsequence.
+    Examples
+    ========
+    >>> from pydatastructs import longest_increasing_subsequence as LIS, OneDimensionalArray as ODA
+    >>> arr1 = [1, 3, 9, 4, 6]
+    >>> lis = LIS(arr1)
+    >>> str(lis)
+    '4'
+    >>> arr1 = [8, 7, 2, 12, 16, 28, 44]
+    >>> lis = LIS(arr1)
+    >>> str(lis)
+    '5'
+
+    References
+    ==========
+    .. [1] https://en.wikipedia.org/wiki/Longest_increasing_subsequence
+
+    """
+    def CeilIndex(A, l, r, key):
+        while (r - l > 1):
+            m = l + (r - l)//2
+            if (A[m] >= key):
+                r = m
+            else:
+                l = m
+        return r
+
+    size = len(seq)
+    tailTable = [0 for i in range(size + 1)]
+    length = 0 # always points empty slot
+
+    tailTable[0] = seq[0]
+    length = 1
+    for i in range(1, size):
+        if (seq[i] < tailTable[0]):
+
+            # new smallest value
+            tailTable[0] = seq[i]
+        elif (seq[i] > tailTable[length-1]):
+
+            # seq[i] wants to extend
+            # largest subsequence
+            tailTable[length] = seq[i]
+            length+= 1
+        else:
+            # seq[i] wants to be current
+            # end candidate of an existing
+            # subsequence. It will replace
+            # ceil value in tailTable
+            tailTable[CeilIndex(tailTable, -1, length-1, seq[i])] = seq[i]
+    return length

pydatastructs/linear_data_structures/tests/test_algorithms.py

@@ -1,7 +1,7 @@
 from pydatastructs import (
     merge_sort_parallel, DynamicOneDimensionalArray,
     OneDimensionalArray, brick_sort, brick_sort_parallel,
-    heapsort, matrix_multiply_parallel, counting_sort, bucket_sort, cocktail_shaker_sort, quick_sort, longest_common_subsequence)
+    heapsort, matrix_multiply_parallel, counting_sort, bucket_sort, cocktail_shaker_sort, quick_sort, longest_common_subsequence, longest_increasing_subsequence)
 
 
 from pydatastructs.utils.raises_util import raises
@@ -102,7 +102,7 @@ def test_matrix_multiply_parallel():
     output = matrix_multiply_parallel(I, J, num_threads=1)
     assert expected_result == output
 
-def test_longest_common_sequence():
+def test_longest_common_subsequence():
     ODA = OneDimensionalArray
     expected_result = "['A', 'S', 'C', 'I', 'I']"
 
@@ -126,3 +126,25 @@ def test_longest_common_sequence():
     Z = ODA(int, [])
     output = longest_common_subsequence(Y, Z)
     assert str(output) == '[]'
+
+def test_longest_increasing_subsequence():
+    ODA = OneDimensionalArray
+    expected_result = "5"
+
+    str1 = ODA(int, [1, 3, 8, 4, 7, 6, 12])
+    output = longest_increasing_subsequence(str1)
+    assert str(output) == expected_result
+
+    expected_result = "3"
+
+    I = ODA(int, [9, 11, 8, 14, 12])
+    output = longest_increasing_subsequence(I)
+    assert str(output) == expected_result
+
+    Y = ODA(int, [1, 2, 3, 4, 4, 3, 7, 9])
+    output = longest_increasing_subsequence(Y)
+    assert str(output) == "6"
+
+    Z = ODA(int, [4, 2, 5, 8, 11])
+    output = longest_increasing_subsequence(Z)
+    assert str(output) == "4"

pydatastructs/utils/tests/test_code_quality.py

@@ -22,7 +22,7 @@ def test_trailing_white_spaces():
             if line.endswith(" \n") or line.endswith("\t\n") \
                 or line.endswith(" ") or line.endswith("\t"):
                 assert False, "%s contains trailing whitespace at %s"\
-                               %(file_path, line)
+                             %(file_path, line)
             line = file.readline()
         file.close()