Adding Shell Sort algorithm

Author: rlishtaba

README.md

@@ -36,6 +36,7 @@ $ pip install py-algorithms
       - Binary Search
 
     ^ Sorting
+      - Shell Sort (Shell method)
       - Heap Sort (Fibonacci heap)
       - Merge Sort
       - Bubble Sort
@@ -120,6 +121,7 @@ sorting_algorithm(xs)
 
 #=> [-1, 0, 4, 5, 6, 7, 8, 9, 12]
 ```
+
 #### *Heap Sort (https://en.wikipedia.org/wiki/Heapsort)
 
 In computer science, heapsort is a comparison-based sorting algorithm.
@@ -143,6 +145,33 @@ sorting_algorithm(xs)
 
 #=> [-1, 0, 4, 5, 6, 7, 8, 9, 12]
 ```
+
+#### *Shell Sort (https://en.wikipedia.org/wiki/Shellsort)
+
+Shellsort, also known as Shell sort or Shell's method, is an in-place comparison sort.
+It can be seen as either a generalization of sorting by exchange (bubble sort) or
+sorting by insertion (insertion sort). The method starts by sorting pairs of elements far apart
+from each other, then progressively reducing the gap between elements to be compared.
+Starting with far apart elements, it can move some out-of-place elements into position faster
+than a simple nearest neighbor exchange. Donald Shell published the first version of this sort in 1959
+The running time of Shellsort is heavily dependent on the gap sequence it uses. For many practical variants,
+determining their time complexity remains an open problem.
+
+    Worst case: О(n^2)
+    Best case: О(n log n)
+    Average: ~
+    Worst case space: O(n)
+
+```python
+from py_algorithms.sort import new_shell_sort
+
+xs = [0, 6, 7, 8, 9, 4, 5, 12, -1]
+sorting_algorithm = new_shell_sort()
+sorting_algorithm(xs)
+
+#=> [-1, 0, 4, 5, 6, 7, 8, 9, 12]
+```
+
 ---
 
 ### Search Algorithms

py_algorithms/sort/__init__.py

@@ -5,6 +5,7 @@
 from ._heap_sort import FibonacciHeapSort
 from ._merge_sort import RecursiveMergeSort
 from ._selection_sort import SelectionSort
+from ._shell_sort import ShellSort
 from .sort import Sort
 
 __all__ = [
@@ -74,3 +75,19 @@ def new_heap_sort() -> Callable[[List[int]], List[int]]:
     """
 
     return lambda xs: FibonacciHeapSort().sort(xs)
+
+
+def new_shell_sort() -> Callable[[List[int]], List[int]]:
+    """
+    - Shell Sort algorithm. Factory method to return sort functor.
+
+        >>> from py_algorithms.sort import new_shell_sort
+        >>>
+        >>> xs = [0, 6, 7, 8, 9, 4, 5, 12, -1]
+        >>> sorting_algorithm = new_heap_sort()
+        >>> sorting_algorithm(xs) #=> [-1, 0, 4, 5, 6, 7, 8, 9, 12]
+
+    :return: a function1 interface to apply
+    """
+
+    return lambda xs: ShellSort().sort(xs)

py_algorithms/sort/_shell_sort.py

@@ -0,0 +1,31 @@
+from typing import List
+
+from ..utils import test_iterable
+from .sort import Sort
+
+
+class ShellSort(Sort):
+    """
+    Worst-case: О(n ^ 2)
+    Best-case: O(n log n)
+    Space: О(n)
+    Stability: true
+    """
+
+    def sort(self, xs: List[int]) -> List[int]:
+        test_iterable(xs)
+
+        inc = len(xs) // 2
+        while inc > 0:
+            for i in range(inc, len(xs)):
+                temp = xs[i]
+                j = i
+                while j >= inc and xs[j - inc] > temp:
+                    xs[j] = xs[j - inc]
+                    j -= inc
+                xs[j] = temp
+            if inc == 2:
+                inc = 1
+            else:
+                inc = int(round(inc // 2.2, 0))
+        return xs

setup.py

@@ -23,7 +23,7 @@
               'fibonacci priority queue', 'max priority queue', 'min priority queue',
               'dynamic connectivity', 'union find', 'quick union', 'weighted quick union',
               'weighted quick union with path compression', 'fibonacci heap sort', 'heapsort',
-              'heap sort'],
+              'heap sort', 'shell-sort', 'shell sort'],
     description="Library of Algorithms, Data Structures, variety of solutions to common "
                 "CS problems",
     long_description="Algorithms and Data Structures implemented using awesome Python.",

tests/conftest.py

@@ -11,6 +11,6 @@ def xs() -> List[int]:
 
 @pytest.fixture
 def large_xs() -> List[int]:
-    raw = [0, 6, 7, 8, 9, 4, 5, 12, -112] * 50
+    raw = [0, 6, 7, 8, 9, 4, 5, 12, -112] * 500
     random.shuffle(raw)
     return raw

tests/py_algorithms/sort/shell_sort_test.py

@@ -0,0 +1,29 @@
+from typing import Callable
+from typing import List
+
+import pytest
+
+from py_algorithms.sort import new_shell_sort
+from tests.conftest import large_xs
+from tests.conftest import xs
+
+
+@pytest.fixture
+def new_sorting_algorithm() -> Callable[[List[int]], List[int]]:
+    return new_shell_sort()
+
+
+class TestSelectionSort:
+    def test_sorting_algorithm(self):
+        f = new_sorting_algorithm()
+        assert sorted(xs()) == f(xs())
+
+    def test_sorting_algorithm_on_large_xs(self):
+        f = new_sorting_algorithm()
+        assert sorted(large_xs()) == f(large_xs())
+
+    def test_non_iterable_xs(self):
+        f = new_sorting_algorithm()
+        for x in (None, 1, ''):
+            with pytest.raises(RuntimeError):
+                f(x)