Made some changes

Author: OmkarPathak

pygorithm/sorting/__pycache__/bubble_sort.cpython-35.pyc

@@ -4,27 +4,27 @@
 # Best O(n); Average O(n); Worst O(n)
 
 # bucket sort algorithm
-def sort(myList, bucketSize = 5):
+def sort(List, bucketSize = 5):
     from pygorithm.sorting import insertion_sort
     import math
 
     string = False
 
-    if(len(myList) == 0):
+    if(len(List) == 0):
         print('You don\'t have any elements in array!')
-    elif all(isinstance(element, str) for element in myList):
+    elif all(isinstance(element, str) for element in List):
         string = True
-        myList = [ord(element) for element in myList]
+        List = [ord(element) for element in List]
 
-    minValue = myList[0]
-    maxValue = myList[0]
+    minValue = List[0]
+    maxValue = List[0]
 
     # For finding minimum and maximum values
-    for i in range(0, len(myList)):
-        if myList[i] < minValue:
-            minValue = myList[i]
-        elif myList[i] > maxValue:
-            maxValue = myList[i]
+    for i in range(0, len(List)):
+        if List[i] < minValue:
+            minValue = List[i]
+        elif List[i] > maxValue:
+            maxValue = List[i]
 
     # Initialize buckets
     bucketCount = math.floor((maxValue - minValue) / bucketSize) + 1
@@ -33,8 +33,8 @@ def sort(myList, bucketSize = 5):
         buckets.append([])
 
     # For putting values in buckets
-    for i in range(0, len(myList)):
-        buckets[math.floor((myList[i] - minValue) / bucketSize)].append(myList[i])
+    for i in range(0, len(List)):
+        buckets[math.floor((List[i] - minValue) / bucketSize)].append(List[i])
 
     # Sort buckets and place back into input array
     sortedArray = []

pygorithm/sorting/__pycache__/bucket_sort.cpython-35.pyc

@@ -4,25 +4,25 @@
 #  Best = Average = Worst =  O(n + k)
 
 # counting sort algorithm
-def sort(myList):
+def sort(List):
     try:
         maxValue = 0
-        for i in range(len(myList)):
-            if myList[i] > maxValue:
-                maxValue = myList[i]
+        for i in range(len(List)):
+            if List[i] > maxValue:
+                maxValue = List[i]
 
         buckets = [0] * (maxValue + 1)
 
-        for i in myList:
+        for i in List:
             buckets[i] += 1
 
         i = 0
         for j in range(maxValue + 1):
              for a in range(buckets[j]):
-                 myList[i] = j
+                 List[i] = j
                  i += 1
 
-        return myList
+        return List
 
     except TypeError:
         print('Counting Sort can only be applied to integers')

pygorithm/sorting/__pycache__/shell_sort.cpython-35.pyc

@@ -4,33 +4,33 @@
 # Best O(nlog(n)); Average O(nlog(n)); Worst O(nlog(n))
 
 # heap sort algorithm
-def sort(alist):
-    heapify(alist)              # create the heap
-    end = len(alist) - 1
+def sort(List):
+    heapify(List)              # create the heap
+    end = len(List) - 1
     while end > 0:
-        alist[end], alist[0] = alist[0], alist[end]
-        shiftDown(alist, 0, end - 1)
+        List[end], List[0] = List[0], List[end]
+        shiftDown(List, 0, end - 1)
         end -= 1
-    return alist
+    return List
 
-def heapify(alist):
+def heapify(List):
     ''' This function helps to maintain the heap property '''
-    # start = (len(alist) - 2) // 2         (faster execution)
-    start = len(alist) // 2
+    # start = (len(List) - 2) // 2         (faster execution)
+    start = len(List) // 2
     while start >= 0:
-        shiftDown(alist, start, len(alist) - 1)
+        shiftDown(List, start, len(List) - 1)
         start -= 1
 
-def shiftDown(alist, start, end):
+def shiftDown(List, start, end):
     root = start
     while root * 2 + 1 <= end:
         child = root * 2 + 1
         # right child exists and is greater than left child
-        if child + 1 <= end and alist[child] < alist[child + 1]:
+        if child + 1 <= end and List[child] < List[child + 1]:
             child += 1
         # if child is greater than root(parent), then swap their positions
-        if child <= end and alist[root] < alist[child]:
-            alist[root], alist[child] = alist[child], alist[root]
+        if child <= end and List[root] < List[child]:
+            List[root], List[child] = List[child], List[root]
             root = child
         else:
             return

pygorithm/sorting/bucket_sort.py

@@ -21,14 +21,14 @@ def merge(a,b):
     return c
 
 # Code for merge sort
-def sort(x):
+def sort(List):
     """ Function to sort an array using merge sort algorithm """
-    if len(x) == 0 or len(x) == 1:
-        return x
+    if len(List) == 0 or len(List) == 1:
+        return List
     else:
         middle = len(x)//2
-        a = sort(x[:middle])
-        b = sort(x[middle:])
+        a = sort(List[:middle])
+        b = sort(List[middle:])
         return merge(a,b)
 
 # time complexities

pygorithm/sorting/counting_sort.py

@@ -4,13 +4,13 @@
 #  Best = Average = O(nlog(n)), Worst = O(n ^ 2)
 
 # quick_sort algorithm
-def sort(arr):
-    if len(arr) <= 1:
-        return arr
-    pivot = arr[len(arr) // 2]
-    left = [x for x in arr if x < pivot]
-    middle = [x for x in arr if x == pivot]
-    right = [x for x in arr if x > pivot]
+def sort(List):
+    if len(List) <= 1:
+        return List
+    pivot = List[len(List) // 2]
+    left = [x for x in List if x < pivot]
+    middle = [x for x in List if x == pivot]
+    right = [x for x in List if x > pivot]
     return sort(left) + middle + sort(right)
 
 # time complexities

pygorithm/sorting/heap_sort.py

@@ -4,19 +4,19 @@
 # Best Case O(n logn); Average Case O(depends on gap sequence); Worst Case O(n^2)
 
 # shell sort algorithm
-def sort(myList):
-    gap = len(myList) // 2
+def sort(List):
+    gap = len(List) // 2
     while gap > 0:
-        for i in range(gap, len(myList)):
-            currentItem = myList[i]
+        for i in range(gap, len(List)):
+            currentItem = List[i]
             j = i
-            while j >= gap and myList[j - gap] > currentItem:
-                myList[j] = myList[j - gap]
+            while j >= gap and List[j - gap] > currentItem:
+                List[j] = List[j - gap]
                 j -= gap
-            myList[j] = currentItem
+            List[j] = currentItem
         gap //= 2
 
-    return myList
+    return List
 
 # time complexities
 def time_complexities():