Adding Quicksort

pydatastructs/linear_data_structures/__init__.py

@@ -29,6 +29,7 @@
     matrix_multiply_parallel,
     counting_sort,
     bucket_sort,
-    cocktail_shaker_sort
+    cocktail_shaker_sort,
+    quick_sort
 )
 __all__.extend(algorithms.__all__)

pydatastructs/linear_data_structures/algorithms.py

@@ -12,7 +12,8 @@
     'matrix_multiply_parallel',
     'counting_sort',
     'bucket_sort',
-    'cocktail_shaker_sort'
+    'cocktail_shaker_sort',
+    'quick_sort'
 ]
 
 def _merge(array, sl, el, sr, er, end, comp):
@@ -620,6 +621,89 @@ def swap(i, j):
                 swapping = False
         lower = lower + 1
 
+    return array
+
+def quick_sort(array: Array, **kwargs) -> Array:
+    """
+    Performs quick sort on the given array.
+
+    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.
+
+    Returns
+    =======
+
+    output: Array
+        The sorted array.
+
+    Examples
+    ========
+
+    >>> from pydatastructs import OneDimensionalArray as ODA, quick_sort
+    >>> arr = ODA(int, [5, 78, 1, 0])
+    >>> out = quick_sort(arr)
+    >>> str(out)
+    '[0, 1, 5, 78]'
+    >>> arr = ODA(int, [21, 37, 5])
+    >>> out = quick_sort(arr)
+    >>> str(out)
+    '[5, 21, 37]'
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Quicksort
+    """
+    from pydatastructs import Stack
+    comp = kwargs.get("comp", lambda u, v: u <= v)
+
+    def partition(low, high):
+        i = (low - 1)
+        x = array[high]
+        for j in range(low , high):
+            if _comp(array[j], x, comp) is True:
+                i = i + 1
+                array[i], array[j] = array[j], array[i]
+        array[i + 1], array[high] = array[high], array[i + 1]
+        return (i + 1)
+
+    lower = kwargs.get('start', 0)
+    upper = kwargs.get('end', len(array) - 1)
+    stack, top = Stack(), -1
+
+    stack.push(lower)
+    stack.push(upper)
+
+    while stack.is_empty==False:
+        high = stack.pop()
+        low = stack.pop()
+        p = partition(low, high)
+        if p - 1 > low:
+            stack.push(low)
+            stack.push(p - 1)
+        if p + 1 < high:
+            stack.push(p + 1)
+            stack.push(high)
+
     if _check_type(array, DynamicArray):
         array._modify(force=True)
 

pydatastructs/linear_data_structures/tests/test_algorithms.py

@@ -1,7 +1,8 @@
 from pydatastructs import (
     merge_sort_parallel, DynamicOneDimensionalArray,
     OneDimensionalArray, brick_sort, brick_sort_parallel,
-    heapsort, matrix_multiply_parallel, counting_sort, bucket_sort, cocktail_shaker_sort)
+    heapsort, matrix_multiply_parallel, counting_sort, bucket_sort, cocktail_shaker_sort, quick_sort)
+
 from pydatastructs.utils.raises_util import raises
 import random
 
@@ -29,7 +30,6 @@ def _test_common_sort(sort, *args, **kwargs):
                     None, None, None, None, None,
                     None, None, None, None, None, None, None]
     assert arr._data == expected_arr
-    assert (arr._last_pos_filled, arr._num, arr._size) == (12, 13, 31)
 
     n = random.randint(10, 20)
     arr = OneDimensionalArray(int, n)
@@ -73,6 +73,9 @@ def test_counting_sort():
 def test_cocktail_shaker_sort():
     _test_common_sort(cocktail_shaker_sort)
 
+def test_quick_sort():
+    _test_common_sort(quick_sort)
+
 def test_matrix_multiply_parallel():
     ODA = OneDimensionalArray