Adding Comb Sort algorithm

Author: rlishtaba

.pre-commit-config.yaml

@@ -1,5 +1,5 @@
 -   repo: https://github.com/pre-commit/pre-commit-hooks.git
-    sha: v0.7.0
+    sha: v0.8.0
     hooks:
     -   id: trailing-whitespace
         args: ['--no-markdown-linebreak-ext']

README.md

@@ -32,13 +32,14 @@ $ pip install py-algorithms
         - Max PQ
       - Suffix Array
 
-    ^ Search
+    ^ Search Algorithms
       - Binary Search
 
-    ^ Sorting
+    ^ Sort Algorithms
       - Shell Sort (Shell method)
       - Heap Sort (Fibonacci heap)
       - Merge Sort
+      - Comb Sort
       - Bubble Sort
       - Selection Sort
 
@@ -98,6 +99,29 @@ sorting_algorithm(xs)
 #=> [-1, 0, 4, 5, 6, 7, 8, 9, 12]
 ```
 
+#### *Comb Sort (https://en.wikipedia.org/wiki/Comb_sort)
+
+Comb sort is a relatively simple sorting algorithm originally designed by
+Włodzimierz Dobosiewicz in 1980. Later it was rediscovered by Stephen Lacey and Richard Box in 1991.
+Comb sort improves on bubble sort. The basic idea is to eliminate turtles,
+or small values near the end of the list, since in a bubble sort these slow the sorting down tremendously.
+Rabbits, large values around the beginning of the list, do not pose a problem in bubble sort.
+
+    Worst case: О(n^2)
+    Best case: О(n log n)
+    Average: О(n^2)
+    Worst case space: O(1)
+
+```python
+from py_algorithms.sort import new_comb_sort
+
+xs = [0, 6, 7, 8, 9, 4, 5, 12, -1]
+sorting_algorithm = new_comb_sort()
+sorting_algorithm(xs)
+
+#=> [-1, 0, 4, 5, 6, 7, 8, 9, 12]
+```
+
 #### *Selection Sort (https://en.wikipedia.org/wiki/Selection_sort)
 
 In computer science, selection sort is a sorting algorithm,

py_algorithms/sort/__init__.py

@@ -2,6 +2,7 @@
 from typing import List
 
 from ._bubble_sort import BubbleSort
+from ._comb_sort import CombSort
 from ._heap_sort import FibonacciHeapSort
 from ._merge_sort import RecursiveMergeSort
 from ._selection_sort import SelectionSort
@@ -12,6 +13,9 @@
     'new_bubble_sort',
     'new_merge_sort',
     'new_selection_sort',
+    'new_heap_sort',
+    'new_shell_sort',
+    'new_comb_sort',
     'Sort'
 ]
 
@@ -91,3 +95,20 @@ def new_shell_sort() -> Callable[[List[int]], List[int]]:
     """
 
     return lambda xs: ShellSort().sort(xs)
+
+
+def new_comb_sort() -> Callable[[List[int]], List[int]]:
+    """
+    - Comb Sort algorithm (Improved on Bubble Sort).
+    Factory method to return sort functor.
+
+        >>> from py_algorithms.sort import new_comb_sort
+        >>>
+        >>> xs = [0, 6, 7, 8, 9, 4, 5, 12, -1]
+        >>> sorting_algorithm = new_comb_sort()
+        >>> sorting_algorithm(xs) #=> [-1, 0, 4, 5, 6, 7, 8, 9, 12]
+
+    :return: a function1 interface to apply
+    """
+
+    return lambda xs: CombSort().sort(xs)

py_algorithms/sort/_comb_sort.py

@@ -0,0 +1,38 @@
+import math
+from typing import List
+
+from ..utils import test_iterable
+from ..utils import three_way_cmp
+from .sort import Sort
+
+
+class CombSort(Sort):
+    _SHRINK = 1.3
+    """
+    Worst-case: О(n^2)
+    Best-case: O(n log n)
+    Space: О(1)
+    Stability: true
+    """
+
+    def sort(self, xs: List[int]) -> List[int]:
+        test_iterable(xs)
+
+        gap = len(xs)
+        in_order = False
+
+        while not in_order:
+            gap = math.floor(gap / self._SHRINK)  # simply gap * 10 // 13
+
+            if gap < 1:
+                gap = 1
+
+            swapped = False
+            for i in range(len(xs) - gap):
+                if three_way_cmp(xs[i], xs[i + gap]) == 1:
+                    xs[i], xs[i + gap] = xs[i + gap], xs[i]
+                    swapped = True
+            if not swapped and gap == 1:
+                in_order = True
+
+        return xs

setup.py

@@ -23,10 +23,12 @@
               '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', 'shell-sort', 'shell sort'],
+              'heap sort', 'shell-sort', 'shell sort', 'comb sort', 'comb-sort'],
     description="Library of Algorithms, Data Structures, variety of solutions to common "
-                "CS problems",
-    long_description="Algorithms and Data Structures implemented using awesome Python.",
+                "CS problems.",
+    long_description="Library of Algorithms, Data Structures, variety of solutions to common "
+                     "CS problems. Algorithms and Data Structures implemented using pure awesome "
+                     "Python.",
     license="MIT",
     url='https://github.com/rlishtaba/py-algorithms',
     scripts=[],

tests/py_algorithms/sort/comb_sort_test.py

@@ -0,0 +1,29 @@
+from typing import Callable
+from typing import List
+
+import pytest
+
+from py_algorithms.sort import new_comb_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_comb_sort()
+
+
+class TestCombSort:
+    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)

tests/py_algorithms/sort/shell_sort_test.py

@@ -13,7 +13,7 @@ def new_sorting_algorithm() -> Callable[[List[int]], List[int]]:
     return new_shell_sort()
 
 
-class TestSelectionSort:
+class TestShellSort:
     def test_sorting_algorithm(self):
         f = new_sorting_algorithm()
         assert sorted(xs()) == f(xs())