Merge pull request #8 from rlishtaba/feature/merge-sort

Adding Merge Sort algorithm

Author: rlishtaba

py_algorithms/sort/__init__.py

@@ -2,17 +2,41 @@
 from typing import List
 
 from ._bubble_sort import BubbleSort
+from ._merge_sort import RecursiveMergeSort
 from .sort import Sort
 
 __all__ = [
     'new_bubble_sort',
+    'new_merge_sort',
     'Sort'
 ]
 
 
 def new_bubble_sort() -> Callable[[List[int]], List[int]]:
     """
-    Factory method to return function to sort
+     Factory method to return sort function
+
+         >>> from py_algorithms.sort import new_merge_sort
+         >>>
+         >>> xs = [0, 6, 7, 8, 9, 4, 5, 12, -112]
+         >>> sorting_algorithm = new_bubble_sort()
+         >>> sorting_algorithm(xs) #=> [-112, 0, 4, 5, 6, 7, 8, 9, 12]
+
+     :return: a function1 interface to apply
+     """
+    return lambda xs: BubbleSort().sort(xs)
+
+
+def new_merge_sort() -> Callable[[List[int]], List[int]]:
+    """
+    Factory method to return sort function
+
+        >>> from py_algorithms.sort import new_merge_sort
+        >>>
+        >>> xs = [0, 6, 7, 8, 9, 4, 5, 12, -1]
+        >>> sorting_algorithm = new_merge_sort()
+        >>> sorting_algorithm(xs) #=> [-1, 0, 4, 5, 6, 7, 8, 9, 12]
+
     :return: a function1 interface to apply
     """
-    return lambda xs: BubbleSort().sort(xs)
+    return lambda xs: RecursiveMergeSort().sort(xs)

py_algorithms/sort/_bubble_sort.py

@@ -15,8 +15,7 @@ class BubbleSort(Sort):
     """
 
     def sort(self, xs: List[int]) -> List[int]:
-        if not isinstance(xs, (list, tuple)):
-            raise RuntimeError('Can sort only iterable entity.')
+        self._test_iterable(xs)
 
         done = False
         while not done:

py_algorithms/sort/_merge_sort.py

@@ -0,0 +1,34 @@
+from typing import List
+
+from .sort import Sort
+
+
+class RecursiveMergeSort(Sort):
+    """
+    Time: О(N log N)
+    Space: О(N)
+    Stability: true
+
+    Recursive implementation
+    """
+
+    def sort(self, xs: List[int]) -> List[int]:
+        self._test_iterable(xs)
+        if len(xs) <= 1:
+            return xs
+
+        mid = len(xs) // 2
+        left = xs[:mid]
+        right = xs[mid:]
+
+        return self.merge(self.sort(left), self.sort(right))
+
+    @staticmethod
+    def merge(left: List[int], right: List[int]) -> List[int]:
+        xs = []
+        while not (len(left) == 0 or len(right) == 0):
+            if left[0] <= right[0]:
+                xs.append(left.pop(0))
+            else:
+                xs.append(right.pop(0))
+        return xs + left + right

py_algorithms/sort/sort.py

@@ -1,8 +1,14 @@
 import abc
+from typing import Any
 from typing import List
 
 
 class Sort(metaclass=abc.ABCMeta):
     @abc.abstractmethod
     def sort(self, xs: List[int]) -> List[int]:
         raise NotImplemented()
+
+    @staticmethod
+    def _test_iterable(xs: Any):
+        if not isinstance(xs, (list, tuple)):
+            raise RuntimeError('Can sort only iterable entity.')

tests/py_algorithms/sort/bubble_sort_test.py

@@ -1,4 +1,5 @@
 import copy
+import random
 from typing import List
 
 import pytest
@@ -8,18 +9,25 @@
 
 @pytest.fixture
 def xs() -> List[int]:
-    return [0, 6, 7, 8, 9, 4, 5, 12]
+    return [0, 6, 7, 8, 9, 4, 5, 12, -112]
 
 
-@pytest.fixture
-def sorted_xs() -> List[int]:
-    return sorted(xs())
+def large_xs() -> List[int]:
+    raw = [0, 6, 7, 8, 9, 4, 5, 12, -112] * 50
+    random.shuffle(raw)
+    return raw
 
 
 class TestBubbleSort:
     def test_sorting_algorithm(self):
         f = new_bubble_sort()
-        assert sorted_xs() == f(xs())
+        assert sorted(xs()) == f(xs())
+        decreasing_xs = [999, 10, 9, 8, 7, 6]
+        assert sorted(copy.copy(decreasing_xs)) == f(decreasing_xs)
+
+    def test_sorting_algorithm_on_large_set(self):
+        f = new_bubble_sort()
+        assert sorted(large_xs()) == f(large_xs())
         decreasing_xs = [999, 10, 9, 8, 7, 6]
         assert sorted(copy.copy(decreasing_xs)) == f(decreasing_xs)
 

tests/py_algorithms/sort/merge_sort_test.py

@@ -0,0 +1,33 @@
+import random
+from typing import List
+
+import pytest
+
+from py_algorithms.sort import new_merge_sort
+
+
+@pytest.fixture
+def xs() -> List[int]:
+    return [0, 6, 7, 8, 9, 4, 5, 12, -1]
+
+
+def large_xs() -> List[int]:
+    raw = [0, 6, 7, 8, 9, 4, 5, 12, -112] * 50
+    random.shuffle(raw)
+    return raw
+
+
+class TestMergeSort:
+    def test_sorting_algorithm(self):
+        f = new_merge_sort()
+        assert sorted(xs()) == f(xs())
+
+    def test_sorting_algorithm_on_large_xs(self):
+        f = new_merge_sort()
+        assert sorted(large_xs()) == f(large_xs())
+
+    def test_non_iterable_xs(self):
+        f = new_merge_sort()
+        for x in (None, 1, ''):
+            with pytest.raises(RuntimeError):
+                f(x)