added shell sort with tests and documentation

Author: arvinder004

AUTHORS

@@ -11,3 +11,4 @@ Pratik Goyal <pratikgoyal2712@gmail.com>
 Jay Thorat <j.thorat10@gmail.com>
 Rajveer Singh Bharadwaj <rsb3256@gmail.com>
 Kishan Ved <kishanved123456@gmail.com>
+Arvinder Singh Dhoul <asdhoul004@gmail.com>

pydatastructs/linear_data_structures/algorithms.py

@@ -1850,3 +1850,78 @@ def partition(array, lower, upper):
         intro_sort(array, start=p+1, end=upper,  maxdepth=maxdepth-1, ins_threshold=ins_threshold)
 
         return array
+
+def shell_sort(array, **kwargs):
+    """
+    Implements shell sort algorithm.
+
+    Parameters
+    ==========
+
+    array: Array
+        The array which is to be sorted.
+    start: int
+        The starting index of the portion
+        which is to be sorted.
+        Optional, by default 0
+    end: int
+        The ending index of the portion which
+        is to be sorted.
+        Optional, by default the index
+        of the last position filled.
+    comp: lambda/function
+        The comparator which is to be used
+        for sorting. If the function returns
+        False then only swapping is performed.
+        Optional, by default, less than or
+        equal to is used for comparing two
+        values.
+    backend: pydatastructs.Backend
+        The backend to be used.
+        Optional, by default, the best available
+        backend is used.
+
+    Returns
+    =======
+
+    output: Array
+        The sorted array.
+
+    Examples
+    ========
+
+    >>> from pydatastructs.linear_data_structures.algorithms import OneDimensionalArray, shell_sort
+    >>> arr = OneDimensionalArray(int, [3, 2, 1])
+    >>> out = shell_sort(arr)
+    >>> str(out)
+    '[1, 2, 3]'
+    >>> out = shell_sort(arr, comp=lambda u, v: u > v)
+    >>> str(out)
+    '[3, 2, 1]'
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Shellsort
+    """
+    backend = kwargs.pop("backend", Backend.PYTHON)
+    if backend == Backend.CPP:
+        return _algorithms.shell_sort(array, **kwargs)
+    start = kwargs.get('start', 0)
+    end = kwargs.get('end', len(array) - 1)
+    comp = kwargs.get('comp', lambda u, v: u <= v)
+    n = end - start + 1
+    gap = n // 2
+    while gap > 0:
+        for i in range(start + gap, end + 1):
+            temp = array[i]
+            j = i
+            while j >= start + gap and not _comp(array[j - gap], temp, comp):
+                array[j] = array[j - gap]
+                j -= gap
+            array[j] = temp
+        gap //= 2
+    if _check_type(array, (DynamicArray, _arrays.DynamicOneDimensionalArray)):
+        array._modify(True)
+
+    return array

pydatastructs/linear_data_structures/tests/test_algorithms.py

@@ -7,6 +7,7 @@
     prev_permutation, bubble_sort, linear_search, binary_search, jump_search,
     selection_sort, insertion_sort, intro_sort, Backend)
 
+from pydatastructs.linear_data_structures.algorithms import shell_sort
 from pydatastructs.utils.raises_util import raises
 import random
 
@@ -414,3 +415,24 @@ def test_binary_search():
 def test_jump_search():
     _test_common_search(jump_search)
     _test_common_search(jump_search, backend=Backend.CPP)
+
+def test_shell_sort():
+    assert shell_sort([]) == []
+
+    assert shell_sort([42]) == [42]
+
+    input_data = [1, 2, 3, 4, 5]
+    expected = [1, 2, 3, 4, 5]
+    assert shell_sort(input_data) == expected
+
+    input_data = [5, 4, 3, 2, 1]
+    expected = [1, 2, 3, 4, 5]
+    assert shell_sort(input_data) == expected
+
+    input_data = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]
+    expected = [1, 1, 2, 3, 3, 4, 5, 5, 6, 9]
+    assert shell_sort(input_data) == expected
+
+    input_data = [-5, 3, -10, 7, 0, -2]
+    expected = [-10, -5, -2, 0, 3, 7]
+    assert shell_sort(input_data) == expected