brick_sort implemented

pydatastructs/linear_data_structures/__init__.py

@@ -21,6 +21,7 @@
 __all__.extend(linked_lists.__all__)
 
 from .algorithms import (
-    merge_sort_parallel
+    merge_sort_parallel,
+    brick_sort
 )
 __all__.extend(algorithms.__all__)

pydatastructs/linear_data_structures/algorithms.py

@@ -5,7 +5,8 @@
 from math import log, floor
 
 __all__ = [
-    'merge_sort_parallel'
+    'merge_sort_parallel',
+    'brick_sort'
 ]
 
 def _merge(array, sl, el, sr, er, end, comp):
@@ -104,3 +105,63 @@ def merge_sort_parallel(array, num_threads, **kwargs):
 
     if _check_type(array, DynamicArray):
         array._modify(force=True)
+
+def brick_sort(array, **kwargs):
+    """
+    Implements Brick Sort / Odd Even sorting 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.
+
+    Examples
+    ========
+    >>> from pydatastructs import OneDimensionalArray, brick_sort
+    >>> arr = OneDimensionalArray(int,[3, 2, 1])
+    >>> brick_sort(arr)
+    >>> [arr[0], arr[1], arr[2]]
+    [1, 2, 3]
+    >>> brick_sort(arr, comp=lambda u, v: u > v)
+    >>> [arr[0], arr[1], arr[2]]
+    [3, 2, 1]
+
+    References
+    ==========
+    .. [1] https://www.geeksforgeeks.org/odd-even-sort-brick-sort/
+    """
+    start = kwargs.get('start', 0)
+    end = kwargs.get('end', len(array) - 1)
+    comp = kwargs.get("comp", lambda u, v: u <= v)
+
+    is_sorted = False
+    while is_sorted is False:
+        is_sorted = True
+        for i in range(start+1, end, 2):
+            if _comp(array[i+1], array[i], comp):
+                array[i], array[i+1] = array[i+1], array[i]
+                is_sorted = False
+        for i in range(start, end, 2):
+            if _comp(array[i+1], array[i], comp):
+                array[i], array[i+1] = array[i+1], array[i]
+                is_sorted = False
+
+    if _check_type(array, DynamicArray):
+        array._modify(force=True)

pydatastructs/linear_data_structures/tests/test_algorithms.py

@@ -1,6 +1,6 @@
 from pydatastructs import (
     merge_sort_parallel, DynamicOneDimensionalArray,
-    OneDimensionalArray)
+    OneDimensionalArray, brick_sort)
 import random
 
 def test_merge_sort_parallel():
@@ -31,3 +31,26 @@ def test_merge_sort_parallel():
                     709, 910]
     merge_sort_parallel(arr, 5, start=2, end=5)
     assert arr._data == expected_arr
+
+def test_brick_sort():
+
+    random.seed(1000)
+    n = 10
+    arr = OneDimensionalArray(int, [random.randint(1,1000) for _ in range(n)])
+    b = sorted(arr)
+    brick_sort(arr)
+    assert b == list(arr)
+
+    arr = OneDimensionalArray(int, [random.randint(1,1000) for _ in range(n)])
+    brick_sort(arr, comp=lambda u, v: u>v)
+    b = list(reversed(sorted(arr)))
+    assert b == list(arr)
+
+    arr = DynamicOneDimensionalArray(int, 0)
+    for i in range(n):
+        arr.append(random.randint(1,1000))
+
+    x = [arr[i] for i in range(arr._last_pos_filled+1)]
+    b = sorted(x)
+    brick_sort(arr)
+    assert b == [arr[i] for i in range(arr._last_pos_filled+1)]