resolved test errors for radix sort and shell sort

Author: arvinder004

pydatastructs/linear_data_structures/algorithms.py

@@ -1853,7 +1853,7 @@ def partition(array, lower, upper):
 
         return array
 
-def shell_sort(array, **kwargs):
+def shell_sort(array, *args, **kwargs):
     """
     Implements shell sort algorithm.
 
@@ -1906,9 +1906,10 @@ def shell_sort(array, **kwargs):
 
     .. [1] https://en.wikipedia.org/wiki/Shellsort
     """
-    start = kwargs.get('start', 0)
-    end = kwargs.get('end', len(array) - 1)
+    start = int(kwargs.get('start', 0))
+    end = int(kwargs.get('end', len(array) - 1))
     comp = kwargs.get('comp', lambda u, v: u <= v)
+
     n = end - start + 1
     gap = n // 2
     while gap > 0:
@@ -1920,12 +1921,13 @@ def shell_sort(array, **kwargs):
                 j -= gap
             array[j] = temp
         gap //= 2
+
     if _check_type(array, (DynamicArray, _arrays.DynamicOneDimensionalArray)):
         array._modify(True)
 
     return array
 
-def radix_sort(array, **kwargs):
+def radix_sort(array, *args, **kwargs):
     """
     Implements radix sort algorithm for non-negative integers.
 
@@ -1977,36 +1979,31 @@ def radix_sort(array, **kwargs):
     """
     start = int(kwargs.get('start', 0))
     end = int(kwargs.get('end', len(array) - 1))
-
-    if start >= end:
-        return array
+    comp = kwargs.get('comp', lambda u, v: u <= v)
 
     n = end - start + 1
-    if n <= 0:
-        return array
-
     max_val = array[start]
     for i in range(start + 1, end + 1):
-        if array[i] > max_val:
+        if array[i] is not None and array[i] > max_val:
             max_val = array[i]
-    if max_val < 0:
-        raise ValueError("Radix sort requires non-negative integers")
-
     exp = 1
     while max_val // exp > 0:
         count = [0] * 10
-        output = [0] * n
+        output = [None] * n
+
         for i in range(start, end + 1):
-            digit = (array[i] // exp) % 10
-            count[digit] += 1
+            if array[i] is not None:
+                digit = (array[i] // exp) % 10
+                count[digit] += 1
 
         for i in range(1, 10):
             count[i] += count[i - 1]
 
         for i in range(end, start - 1, -1):
-            digit = (array[i] // exp) % 10
-            count[digit] -= 1
-            output[count[digit]] = array[i]
+            if array[i] is not None:
+                digit = (array[i] // exp) % 10
+                count[digit] -= 1
+                output[count[digit]] = array[i]
 
         for i in range(n):
             array[start + i] = output[i]

pydatastructs/linear_data_structures/tests/test_algorithms.py

@@ -416,43 +416,7 @@ def test_jump_search():
     _test_common_search(jump_search, backend=Backend.CPP)
 
 def test_shell_sort():
-    assert shell_sort([]) == []
-
-    assert shell_sort([42]) == [42]
-
-    input_data = [1, 2, 3, 4, 5]
-    expected = [1, 2, 3, 4, 5]
-    assert shell_sort(input_data) == expected
-
-    input_data = [5, 4, 3, 2, 1]
-    expected = [1, 2, 3, 4, 5]
-    assert shell_sort(input_data) == expected
-
-    input_data = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]
-    expected = [1, 1, 2, 3, 3, 4, 5, 5, 6, 9]
-    assert shell_sort(input_data) == expected
-
-    input_data = [-5, 3, -10, 7, 0, -2]
-    expected = [-10, -5, -2, 0, 3, 7]
-    assert shell_sort(input_data) == expected
+    _test_common_sort(shell_sort)
 
 def test_radix_sort():
-    assert radix_sort([]) == []
-
-    assert radix_sort([42]) == [42]
-
-    input_data = [1, 2, 3, 4, 5]
-    expected = [1, 2, 3, 4, 5]
-    assert radix_sort(input_data) == expected
-
-    input_data = [5, 4, 3, 2, 1]
-    expected = [1, 2, 3, 4, 5]
-    assert radix_sort(input_data) == expected
-
-    input_data = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]
-    expected = [1, 1, 2, 3, 3, 4, 5, 5, 6, 9]
-    assert radix_sort(input_data) == expected
-
-    input_data = [1000, 10, 100, 1, 10000]
-    expected = [1, 10, 100, 1000, 10000]
-    assert radix_sort(input_data) == expected
+    _test_common_sort(radix_sort)