Preparing all of the algorithms for comparison test

Author: KyattPL

algorithms/Comparison.py

@@ -0,0 +1,22 @@
+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 random import randint
+
+how_many = 1000
+lower_integer = 0
+upper_integer = 99
+
+if __name__ == "__main__":
+    array = []
+    for i in range(how_many):
+        array.append(randint(lower_integer, upper_integer))

algorithms/LSDradixSort.py

@@ -1,36 +1,45 @@
 from random import randint
 
-def counting_sort(arr, exp):
+
+def counting_sort(arr, exp, comps, accesses):
     n = len(arr)
     newArr = [0] * n
     count = [0] * 10
     for i in range(n):
-        index = arr[i]/exp
+        accesses += 1
+        index = arr[i]//exp
         count[index % 10] += 1
-    for i in range(1,10):
+    for i in range(1, 10):
         count[i] += count[i-1]
     i = n - 1
     while i >= 0:
-        index = arr[i]/exp
+        accesses += 1
+        index = arr[i]//exp
         newArr[count[index % 10] - 1] = arr[i]
         count[index % 10] -= 1
         i -= 1
     for i in range(len(arr)):
+        accesses += 1
         arr[i] = newArr[i]
-    return arr
+    return (comps, accesses)
 
 
 def lsd_radix_sort(arr):
+    comparisons = len(arr) - 1
+    array_accesses = len(arr)
     maximum = max(arr)
     exp = 1
-    while maximum/exp > 0:
-        counting_sort(arr, exp)
+    while maximum/exp >= 1:
+        (comparisons, array_accesses) = counting_sort(
+            arr, exp, comparisons, array_accesses)
         exp *= 10
-    return arr
+    print("LSD Radix 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(lsd_radix_sort(array))
+        array.append(randint(0, 10))
+    lsd_radix_sort(array)

algorithms/bubbleSort.py

@@ -1,19 +1,27 @@
 from random import random
 
+
 def bubble_sort(arr):
+    comparisons = 0
+    array_accesses = 0
     for i in range(len(arr)):
         swapped = False
         for j in range(len(arr) - i - 1):
+            comparisons += 1
+            array_accesses += 2
             if arr[j] > arr[j + 1]:
+                array_accesses += 2
                 arr[j + 1], arr[j] = arr[j], arr[j + 1]
                 swapped = True
         if not swapped:
             break
-    return arr
+    print("Bubble sort:")
+    print("No. comparisons: " + str(comparisons) +
+          ", no. array accesses: " + str(array_accesses))
+
 
 if __name__ == "__main__":
     array = []
     for i in range(20):
         array.append(random())
     bubble_sort(array)
-    print(bubble_sort(array))

algorithms/bucketSort.py

@@ -1,26 +1,50 @@
 from random import randint
-from insertionSort import insertion_sort
+
+
+def insertion_sort(arr, comps, accesses):
+    for i in range(1, len(arr)):
+        accesses += 1
+        chosenElem = arr[i]
+        j = i - 1
+        comps += 1
+        accesses += 1
+        while j >= 0 and arr[j] > chosenElem:
+            comps += 1
+            accesses += 1
+            arr[j+1] = arr[j]
+            j -= 1
+        accesses += 1
+        arr[j+1] = chosenElem
+    return (comps, accesses)
+
 
 def bucket_sort(arr, k=5):
+    comparisons = 0
+    array_accesses = 0
+
     buckets = []
     for i in range(k):
         buckets.append([])
     newTab = []
     maximum = max(arr)
     for i in range(len(arr)):
+        array_accesses += 1
         index = int(k * arr[i] / maximum)
         if index == k:
             index -= 1
         buckets[index].append(arr[i])
     for i in range(k):
-        buckets[i] = insertion_sort(buckets[i])
+        (comparisons, array_accesses) = insertion_sort(
+            buckets[i], comparisons, array_accesses)
         for j in range(len(buckets[i])):
             newTab.append(buckets[i][j])
-    return newTab
+    print("Bucket 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, 9))
-    print(bucket_sort(array))
+    bucket_sort(array)

algorithms/combSort.py

@@ -1,6 +1,9 @@
 from random import random
 
+
 def comb_sort(arr):
+    comparisons = 0
+    array_accesses = 0
     factor = 1.3
     gap = len(arr)
     isSorted = False
@@ -11,14 +14,19 @@ def comb_sort(arr):
             factor = 1
         for i in range(len(arr) - gap):
             offsetIndex = gap + i
+            array_accesses += 2
+            comparisons += 1
             if arr[i] > arr[offsetIndex]:
+                array_accesses += 2
                 arr[i], arr[offsetIndex] = arr[offsetIndex], arr[i]
                 isSorted = False
-    return arr
+    print("Comb 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(comb_sort(array))
+    comb_sort(array)

algorithms/countingSort.py

@@ -1,21 +1,29 @@
 from random import randint
 
+
 def counting_sort(arr):
+    comparisons = 2 * len(arr)
+    array_accesses = 2 * len(arr)
     spread = max(arr) - min(arr) + 1
     countArr = [0] * spread
     newArr = [0] * len(arr)
     for i in range(len(arr)):
+        array_accesses += 2
         countArr[arr[i]] += 1
     for i in range(1, spread):
+        array_accesses += 2
         countArr[i] += countArr[i-1]
     for i in range(len(arr)-1, -1, -1):
+        array_accesses += 4
         countArr[arr[i]] -= 1
         newArr[countArr[arr[i]]] = arr[i]
-    return newArr
+    print("Counting 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(counting_sort(array))
+        array.append(randint(0, 10))
+    counting_sort(array)

algorithms/heapSort.py

@@ -0,0 +1,51 @@
+from random import random
+
+
+def heapify(arr, n, i, comps, accesses):
+    largest = i
+    l = 2*i + 1
+    r = 2*i + 2
+
+    comps += 1
+    accesses += 2
+    if l < n and arr[i] < arr[l]:
+        largest = l
+
+    comps += 1
+    accesses += 2
+    if r < n and arr[largest] < arr[r]:
+        largest = r
+
+    if largest != i:
+        accesses += 4
+        arr[i], arr[largest] = arr[largest], arr[i]
+        (comps, accesses) = heapify(arr, n, largest, comps, accesses)
+
+    return (comps, accesses)
+
+
+def heap_sort(arr):
+    comparisons = 0
+    array_accesses = 0
+
+    n = len(arr)
+    for i in range(n//2 - 1, -1, -1):
+        (comparisons, array_accesses) = heapify(
+            arr, n, i, comparisons, array_accesses)
+
+    for i in range(n-1, 0, -1):
+        array_accesses += 4
+        arr[i], arr[0] = arr[0], arr[i]
+        (comparisons, array_accesses) = heapify(
+            arr, i, 0, comparisons, array_accesses)
+
+    print("Heap sort:")
+    print("No. comparisons: " + str(comparisons) +
+          ", no. array accesses: " + str(array_accesses))
+
+
+if __name__ == "__main__":
+    array = []
+    for i in range(20):
+        array.append(random())
+    heap_sort(array)

algorithms/insertionSort.py

@@ -1,18 +1,28 @@
 from random import random
 
+
 def insertion_sort(arr):
+    comparisons = 0
+    array_accesses = 0
     for i in range(1, len(arr)):
+        array_accesses += 1
         chosenElem = arr[i]
         j = i - 1
+        array_accesses += 1
+        comparisons += 1
         while j >= 0 and arr[j] > chosenElem:
+            array_accesses += 2
             arr[j+1] = arr[j]
             j -= 1
+        array_accesses += 1
         arr[j+1] = chosenElem
-    return arr
+    print("Insertion 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(insertion_sort(array))
+    insertion_sort(array)

algorithms/mergeSort.py

@@ -1,39 +1,52 @@
 from random import random
 
-def merge_sort(arr): 
-    if len(arr) >1: 
+
+def merge_sort(arr):
+    comparisons = 0
+    array_accesses = 0
+    if len(arr) > 1:
+        array_accesses += len(arr)
         mid = len(arr)//2
         L = arr[:mid]
         R = arr[mid:]
-  
-        merge_sort(L)
-        merge_sort(R)
-  
+
+        (comparisons, array_accesses) = merge_sort(L)
+        (comparisons, array_accesses) = merge_sort(R)
+
         i = j = k = 0
-          
-        while i < len(L) and j < len(R): 
-            if L[i] < R[j]: 
-                arr[k] = L[i] 
-                i+= 1
-            else: 
-                arr[k] = R[j] 
-                j+= 1
-            k+= 1
-
-        while i < len(L): 
-            arr[k] = L[i] 
-            i+= 1
-            k+= 1
-          
-        while j < len(R): 
-            arr[k] = R[j] 
-            j+= 1
-            k+= 1
 
+        while i < len(L) and j < len(R):
+            comparisons += 1
+            array_accesses += 4
+            if L[i] < R[j]:
+                arr[k] = L[i]
+                i += 1
+            else:
+                arr[k] = R[j]
+                j += 1
+            k += 1
+
+        while i < len(L):
+            array_accesses += 2
+            arr[k] = L[i]
+            i += 1
+            k += 1
+
+        while j < len(R):
+            array_accesses += 2
+            arr[k] = R[j]
+            j += 1
+            k += 1
+
+    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)
-    print(array)