Merge branch 'master' of https://github.com/TheAlgorithms/Python

Author: anirudhajith

sorts/bucket_sort.py

@@ -14,34 +14,22 @@
 #  Best Case O(n); Average Case O(n); Worst Case O(n)
 
 DEFAULT_BUCKET_SIZE=5
-def bucket_sort(my_list,bucket_size=DEFAULT_BUCKET_SIZE):
-    if(my_list==0):
-        print("you don't have any elements in array!")
 
+def bucket_sort(my_list, bucket_size=DEFAULT_BUCKET_SIZE):
+    if len(my_list) == 0:
+        raise Exception("Please add some elements in the array.")
 
-    min_value=min(my_list)
-    max_value=max(my_list)
+    min_value, max_value = (min(my_list), max(my_list))
+    bucket_count = ((max_value - min_value) // bucket_size + 1)
+    buckets = [[] for _ in range(int(bucket_count))]
 
-    bucket_count=(max_value-min_value)//bucket_size+1
-    buckets=[]
-    for i in range(bucket_count):
-        buckets.append([])
     for i in range(len(my_list)):
-        buckets[(my_list[i]-min_value)//bucket_size].append(my_list[i])
+        buckets[int((my_list[i] - min_value) // bucket_size)].append(my_list[i])
 
+    return sorted([buckets[i][j] for i in range(len(buckets))
+                                 for j in range(len(buckets[i]))])
 
-    sorted_array=[]
-    for i in range(len(buckets)):
-        buckets[i].sort()
-        for j in range(len(buckets[i])):
-            sorted_array.append(buckets[i][j])
-    return sorted_array
-
-
-
-
-#test
-#best on python 3.7.3
-user_input =input('Enter numbers separated by a comma:').strip()
-unsorted =[int(item) for item in user_input.split(',')]
-print(bucket_sort(unsorted))
+if __name__ == "__main__":
+    user_input = input('Enter numbers separated by a comma:').strip()
+    unsorted = [float(n) for n in user_input.split(',') if len(user_input) > 0]
+    print(bucket_sort(unsorted))

sorts/pigeon_sort.py

@@ -0,0 +1,50 @@
+'''
+    This is an implementation of Pigeon Hole Sort.
+'''
+
+from __future__ import print_function
+
+def pigeon_sort(array):
+    # Manually finds the minimum and maximum of the array.
+    min = array[0]
+    max = array[0]
+
+    for i in range(len(array)):
+        if(array[i] < min): min = array[i]
+        elif(array[i] > max): max = array[i]
+
+    # Compute the variables
+    holes_range = max-min + 1
+    holes = [0 for _ in range(holes_range)]
+    holes_repeat = [0 for _ in range(holes_range)]
+
+    # Make the sorting.
+    for i in range(len(array)):
+        index = array[i] - min
+        if(holes[index] != array[i]):
+            holes[index] = array[i]
+            holes_repeat[index] += 1
+        else: holes_repeat[index] += 1
+
+    # Makes the array back by replacing the numbers.
+    index = 0
+    for i in range(holes_range):
+        while(holes_repeat[i] > 0):
+            array[index] = holes[i]
+            index += 1
+            holes_repeat[i] -= 1
+
+    # Returns the sorted array.
+    return array
+
+if __name__ == '__main__':
+    try:
+        raw_input           # Python2
+    except NameError:
+        raw_input = input   # Python 3
+    
+    user_input = raw_input('Enter numbers separated by comma:\n')
+    unsorted = [int(x) for x in user_input.split(',')]
+    sorted = pigeon_sort(unsorted)
+
+    print(sorted)

sorts/quick_sort.py

@@ -34,8 +34,16 @@ def quick_sort(collection):
         return collection
     else:
         pivot = collection[0]
-        greater = [element for element in collection[1:] if element > pivot]
-        lesser = [element for element in collection[1:] if element <= pivot]
+        # Modify the list comprehensions to reduce the number of judgments, the speed has increased by more than 50%.
+        greater = []
+        lesser = []
+        for element in collection[1:]:
+            if element > pivot:
+                greater.append(element)
+            else:
+                lesser.append(element)
+        # greater = [element for element in collection[1:] if element > pivot]
+        # lesser = [element for element in collection[1:] if element <= pivot]
         return quick_sort(lesser) + [pivot] + quick_sort(greater)