Merge pull request larymak#263 from neil-codes/main

Added Counting Sort and Radix Sort

Author: larymak

Data Structures and Algorithms/README.md

@@ -8,6 +8,8 @@
 
 - Bogo Sort
 
+- Counting Sort
+
 - Linear search (for numbers)
 
 - Linear search (for strings)
@@ -28,6 +30,8 @@
 
 - Quick Sort (for strings)
 
+- Radix Sort
+
 - Recursion
 
 - Recursive Binary Search

Data Structures and Algorithms/counting_sort.py

@@ -0,0 +1,41 @@
+def counting_sort(list):
+    """
+    sorts a list of nonnegative integers in ascending order
+    
+    takes O(n + k) time where
+    k is the maximum value in the list
+    n is the length of the list
+    """
+
+    k = max(list)
+    n = len(list)
+    count = [0] * (k+1)
+    new_lst = [0] * n
+
+    # Counting Sort algorithm
+    for i in range(n):
+        count[list[i]] += 1
+
+    for i in range(1, k+1):
+        count[i] += count[i-1]
+
+    for i in range(n):
+        new_lst[count[list[i]]-1] = list[i]
+        count[list[i]] -= 1
+
+    # Copy elements back into original list
+    for i in range(n):
+        list[i] = new_lst[i]
+
+    return list
+
+# Test Case
+def verify(list):
+    list_copy = list[:]
+    list_copy.sort()
+    return list == list_copy
+
+test_list = [1, 3, 1, 4, 10, 6, 3, 4, 5, 8, 3, 4, 8]
+sorted = counting_sort(test_list)
+print(sorted)
+print(verify(sorted))

Data Structures and Algorithms/counting_sort_2.py

@@ -0,0 +1,44 @@
+def counting_sort(list, digit):
+    """
+    sorts a list of nonnegative integers in ascending order
+    unstable version used as a helper for radix sort
+
+    takes O(n + k) time where
+    k is the maximum value in the list
+    n is the length of the list
+    """
+    n = len(list)
+    count = [0] * 10
+    new_list = [0] * n
+
+    for i in range(n) :
+        index = int((list[i]/digit)%10)
+        count[index] += 1
+
+    for i in range(1, 10):
+        count[i] = count[i] + count[i-1]
+
+    for i in range (n-1, -1, -1):
+        index = int((list[i]/digit)%10)
+        new_list[count[index]-1] = list[i]
+        count[index] -= 1
+
+    for i in range(n):
+        list[i] = new_list[i]
+
+    return list
+
+# Test Case
+def verify(list):
+    list_copy = list[:]
+    list_copy.sort()
+    return list == list_copy
+
+def main():
+    test_list = [1, 3, 1, 4, 9, 6, 3, 4, 5, 8, 3, 4, 8]
+    sorted = counting_sort(test_list, 1)
+    print(sorted)
+    print(verify(sorted))
+
+if __name__ == "__main__":
+    main()

Data Structures and Algorithms/radix_sort.py

@@ -0,0 +1,27 @@
+from counting_sort_2 import counting_sort, verify
+
+def radix_sort(list):
+    """
+    sorts a list of integers in ascending order in a particular base
+    
+    takes O(d(n + k)) where:
+    d is the number of digits of the maximum element
+    k is the maximum value in the list
+    n is the length of the list
+    """
+
+    max_val = max(list)
+    digit = 1
+
+    while digit < max_val:
+        counting_sort(list, digit)
+        digit *= 10
+
+    return list
+
+# Test Case
+test_list = [54, 897, 434, 4, 8, 209, 33, 578, 443, 930, 564, 25, 347, 6, 1]
+sorted = radix_sort(test_list)
+print(sorted)
+print(verify(sorted))
+