Adding Fibonacci Heap Sort algorithm

Author: rlishtaba

README.md

@@ -36,8 +36,9 @@ $ pip install py-algorithms
       - Binary Search
 
     ^ Sorting
-      - Bubble Sort
+      - Heap Sort (Fibonacci heap)
       - Merge Sort
+      - Bubble Sort
       - Selection Sort
 
     ^ Agorithms
@@ -117,6 +118,29 @@ xs = [0, 6, 7, 8, 9, 4, 5, 12, -1]
 sorting_algorithm = new_selection_sort()
 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.
+Heapsort can be thought of as an improved selection sort: like that algorithm,
+it divides its input into a sorted and an unsorted region, and it iteratively
+shrinks the unsorted region by extracting the largest element and moving
+that to the sorted region. The improvement consists of the use of a heap data structure
+rather than a linear-time search to find the maximum.
+
+    Worst case: О(n log n)
+    Best case: О(n)
+    Average: О(n log n)
+    Worst case space: O(1)
+
+```python
+from py_algorithms.sort import new_heap_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]
 ```
 ---

py_algorithms/data_structures/heap.py

@@ -4,6 +4,8 @@
 from typing import List
 from typing import Union
 
+from ..utils import test_iterable
+
 
 class _HeapNode:
     def __init__(self, key: Any, value: Any):
@@ -21,7 +23,10 @@ def is_marked(self) -> bool:
 
 
 class Heap:
+    MAX_MIN = -sys.maxsize
+
     def __init__(self, comparator_f2: Callable[[Any, Any], bool], xs: List[Any] = ()):
+        test_iterable(xs)
         self._size = 0
         self._comparator_f2 = comparator_f2
         self._next = None
@@ -39,11 +44,11 @@ def _get_by_index(array, index) -> Union[None, Any]:
 
     @classmethod
     def _set_entry_by_index(cls, array, index, value):
-        if cls._get_by_index(array, index) == -sys.maxsize:
+        if cls._get_by_index(array, index) == cls.MAX_MIN:
             array[index] = value
             return array
         else:
-            array.extend([-sys.maxsize] * (index - len(array) + 1))
+            array.extend([cls.MAX_MIN] * (index - len(array) + 1))
             return cls._set_entry_by_index(array, index, value)
 
     @property
@@ -78,7 +83,7 @@ def contains_key(self, key) -> bool:
         return False
 
     def push(self, key: Any, value: any) -> Any:
-        if not key:
+        if key is None:
             raise RuntimeError('Could not process heap keys equal to Null.')
 
         node = _HeapNode(key, value)
@@ -174,7 +179,7 @@ def _consolidate(self):
                 # we'll try to consolidate them
                 degree = root.degree
 
-                while self._get_by_index(degrees, degree):
+                while not (self._get_by_index(degrees, degree) in [self.MAX_MIN, None]):
                     other_root_with_degree = degrees[degree]
 
                     if self._comparator_f2(root.key, other_root_with_degree.key):
@@ -185,7 +190,7 @@ def _consolidate(self):
                         smaller, larger = other_root_with_degree, root
 
                     self._link_nodes(larger, smaller)
-                    degrees[degree] = -sys.maxsize
+                    degrees[degree] = self.MAX_MIN
                     root = smaller
                     degree += 1
 

py_algorithms/sort/__init__.py

@@ -2,6 +2,7 @@
 from typing import List
 
 from ._bubble_sort import BubbleSort
+from ._heap_sort import FibonacciHeapSort
 from ._merge_sort import RecursiveMergeSort
 from ._selection_sort import SelectionSort
 from .sort import Sort
@@ -57,3 +58,19 @@ def new_selection_sort() -> Callable[[List[int]], List[int]]:
     :return: a function1 interface to apply
     """
     return lambda xs: SelectionSort().sort(xs)
+
+
+def new_heap_sort() -> Callable[[List[int]], List[int]]:
+    """
+    - Fibonacci Heap Sort. Factory method to return sort functor.
+
+        >>> from py_algorithms.sort import new_heap_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: FibonacciHeapSort().sort(xs)

py_algorithms/sort/_bubble_sort.py

@@ -1,5 +1,6 @@
 from typing import List
 
+from ..utils import test_iterable
 from ..utils import three_way_cmp
 from .sort import Sort
 
@@ -15,7 +16,7 @@ class BubbleSort(Sort):
     """
 
     def sort(self, xs: List[int]) -> List[int]:
-        self._test_iterable(xs)
+        test_iterable(xs)
 
         done = False
         while not done:

py_algorithms/sort/_heap_sort.py

@@ -0,0 +1,35 @@
+from typing import List
+
+from ..data_structures import new_min_heap
+from ..utils import test_iterable
+from .sort import Sort
+
+
+class FibonacciHeapSort(Sort):
+    """
+    - Fibonacci Heap Sort. Factory method to return sort functor.
+
+        >>> from py_algorithms.sort import new_heap_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]
+
+    Worst case: О(n log n)
+    Best case: О(n)
+    Average: О(n log n)
+    Worst case space: O(1)
+    """
+
+    def sort(self, xs: List[int]) -> List[int]:
+        test_iterable(xs)
+
+        heap = new_min_heap(xs)
+        xs = []
+        while not heap.is_empty:
+            xs.append(heap.pop())
+        return xs
+
+
+class HeapSort(FibonacciHeapSort):
+    pass

py_algorithms/sort/_merge_sort.py

@@ -1,5 +1,6 @@
 from typing import List
 
+from ..utils import test_iterable
 from .sort import Sort
 
 
@@ -13,7 +14,7 @@ class RecursiveMergeSort(Sort):
     """
 
     def sort(self, xs: List[int]) -> List[int]:
-        self._test_iterable(xs)
+        test_iterable(xs)
         if len(xs) <= 1:
             return xs
 

py_algorithms/sort/_selection_sort.py

@@ -1,5 +1,6 @@
 from typing import List
 
+from ..utils import test_iterable
 from ..utils import three_way_cmp
 from .sort import Sort
 
@@ -12,7 +13,7 @@ class SelectionSort(Sort):
     """
 
     def sort(self, xs: List[int]) -> List[int]:
-        self._test_iterable(xs)
+        test_iterable(xs)
 
         for i in range(0, len(xs)):
             min_val = i

py_algorithms/sort/sort.py

@@ -1,14 +1,8 @@
 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.')

py_algorithms/utils.py

@@ -7,3 +7,8 @@ def three_way_cmp(a: Any, b: Any) -> int:
         single operation, in accordance with the mathematical law of trichotomy.
     """
     return (a > b) - (a < b)
+
+
+def test_iterable(xs: Any):
+    if not isinstance(xs, (list, tuple)):
+        raise RuntimeError('Can sort only iterable entity.')

setup.py

@@ -22,7 +22,8 @@
               'heap', 'fibonacci heap', 'max heap', 'min heap', 'priority queue',
               'fibonacci priority queue', 'max priority queue', 'min priority queue',
               'dynamic connectivity', 'union find', 'quick union', 'weighted quick union',
-              'weighted quick union with path compression'],
+              'weighted quick union with path compression', 'fibonacci heap sort', 'heapsort',
+              'heap 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/py_algorithms/sort/heap_sort_test.py

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