made Comparison.py which tests all of the included algorithms and provides a feedback on comparisons/array_accesses number

Author: KyattPL

.gitignore

@@ -0,0 +1,2 @@
+algorithms/__pycache__
+*.pyc

algorithms/Comparison.py

@@ -1,14 +1,14 @@
-from algorithms.bubbleSort import bubble_sort
-from algorithms.bucketSort import bucket_sort
-from algorithms.combSort import comb_sort
-from algorithms.countingSort import counting_sort
-from algorithms.heapSort import heap_sort
-from algorithms.insertionSort import insertion_sort
-from algorithms.LSDradixSort import lsd_radix_sort
-from algorithms.mergeSort import merge_sort
-from algorithms.pigeonholeSort import pigeonhole_sort
-from algorithms.quickSort import quick_sort
-from algorithms.selectionSort import selection_sort
+from bubbleSort import bubble_sort
+from bucketSort import bucket_sort
+from combSort import comb_sort
+from countingSort import counting_sort
+from heapSort import heap_sort
+from insertionSort import insertion_sort
+from LSDradixSort import lsd_radix_sort
+from mergeSort import merge_sort
+from pigeonholeSort import pigeonhole_sort
+from quickSort import quick_sort
+from selectionSort import selection_sort
 
 from random import randint
 
@@ -20,3 +20,31 @@
     array = []
     for i in range(how_many):
         array.append(randint(lower_integer, upper_integer))
+    temp = array[:]
+    bubble_sort(temp)
+    temp = array[:]
+    bucket_sort(temp)
+    temp = array[:]
+    comb_sort(temp)
+    temp = array[:]
+    counting_sort(temp)
+    temp = array[:]
+    heap_sort(temp)
+    temp = array[:]
+    insertion_sort(temp)
+    temp = array[:]
+    lsd_radix_sort(temp)
+    temp = array[:]
+    pigeonhole_sort(temp)
+    temp = array[:]
+    selection_sort(temp)
+    temp = array[:]
+    (comparisons, array_accesses) = merge_sort(temp)
+    print("Merge sort:")
+    print("No. comparisons: " + str(comparisons) +
+          ", no. array accesses: " + str(array_accesses))
+    temp = array[:]
+    (comparisons, array_accesses) = quick_sort(temp, 0, len(temp) - 1, 0, 0)
+    print("Quick sort:")
+    print("No. comparisons: " + str(comparisons) +
+          ", no. array accesses: " + str(array_accesses))

algorithms/insertionSort.pyc

@@ -41,12 +41,11 @@ def merge_sort(arr):
     return (comparisons, array_accesses)
 
 
-print("Merge sort:")
-print("No. comparisons: " + str(comparisons) +
-      ", no. array accesses: " + str(array_accesses))
-
 if __name__ == "__main__":
     array = []
     for i in range(20):
         array.append(random())
-    merge_sort(array)
+    (comparisons, array_accesses) = merge_sort(array)
+    print("Merge sort:")
+    print("No. comparisons: " + str(comparisons) +
+          ", no. array accesses: " + str(array_accesses))

algorithms/mergeSort.py

@@ -1,21 +1,29 @@
 from random import randint
 
+
 def pigeonhole_sort(arr):
+    comparisons = 2*len(arr)
+    array_accesses = 2*len(arr)
     minimum = min(arr)
     size = max(arr) - minimum + 1
     holes = [0] * size
     for x in arr:
+        array_accesses += 1
         holes[x - minimum] += 1
     i = 0
     for count in range(size):
         while holes[count] > 0:
             holes[count] -= 1
+            array_accesses += 1
             arr[i] = count + minimum
             i += 1
-    return arr
+    print("Pigeonhole sort:")
+    print("No. comparisons: " + str(comparisons) +
+          ", no. array accesses: " + str(array_accesses))
+
 
 if __name__ == "__main__":
     array = []
     for i in range(20):
         array.append(randint(0, 10))
-    print(pigeonhole_sort(array))
+    pigeonhole_sort(array)

algorithms/pigeonholeSort.py

@@ -1,28 +1,37 @@
 from random import random
 
 
-def partition(arr, bottom, top):
+def partition(arr, bottom, top, comps, accesses):
     i = bottom - 1
     pivot = arr[top]
     for j in range(bottom, top):
+        accesses += 1
+        comps += 1
         if arr[j] < pivot:
             i += 1
+            accesses += 3
             arr[i], arr[j] = arr[j], arr[i]
 
+    accesses += 4
     arr[i+1], arr[top] = arr[top], arr[i+1]
-    return (i + 1)
+    return (i + 1, comps, accesses)
 
 
-def quick_sort(arr, bottom, top):
+def quick_sort(arr, bottom, top, comps, accesses):
     if bottom < top:
-        pi = partition(arr, bottom, top)
-        quick_sort(arr, bottom, pi-1)
-        quick_sort(arr, pi+1, top)
+        (pi, comps2, accesses2) = partition(arr, bottom, top, comps, accesses)
+        comps += comps2
+        accesses += accesses2
+        quick_sort(arr, bottom, pi-1, comps, accesses)
+        quick_sort(arr, pi+1, top, comps, accesses)
+    return (comps, accesses)
 
 
 if __name__ == "__main__":
     array = []
     for i in range(20):
         array.append(random())
-    quick_sort(array, 0, len(array) - 1)
-    print(array)
+    (comparisons, array_accesses) = quick_sort(array, 0, len(array) - 1, 0, 0)
+    print("Quick sort:")
+    print("No. comparisons: " + str(comparisons) +
+          ", no. array accesses: " + str(array_accesses))

algorithms/quickSort.py

@@ -1,17 +1,26 @@
 from random import random
 
+
 def selection_sort(arr):
+    comparisons = 0
+    array_accesses = 0
     for i in range(len(arr)):
         minimum = i
         for j in range(i+1, len(arr)):
+            array_accesses += 2
+            comparisons += 1
             if arr[j] < arr[minimum]:
                 minimum = j
         if minimum != i:
+            array_accesses += 4
             arr[i], arr[minimum] = arr[minimum], arr[i]
-    return arr
+    print("Selection sort:")
+    print("No. comparisons: " + str(comparisons) +
+          ", no. array accesses: " + str(array_accesses))
+
 
 if __name__ == "__main__":
     array = []
     for i in range(20):
         array.append(random())
-    print(selection_sort(array))
+    selection_sort(array)