Fixed Bucket Sort and added Gnome, Comb and Cocktail Sort

Author: pattersonrptr

src/main/main.py

@@ -3,17 +3,75 @@
 
 @author: patterson
 '''
+
+from pyqtgraph.python2_3 import xrange
 import random
+import time
 
 from sort.sort import bubble, insertion, selection, quick, merge, shell, heap, \
-    counting, radix, bucket
+    counting, radix, bucket, gnome, comb, cocktail
 
 
 if __name__ == '__main__':
-    vet = [i for i in random.sample(range(100), 10)]
-    # vet = [171]
-    print(vet)
-    print( bucket(vet) )
 
-
-
+    algorithms = [ 'Bubble', 'Insertion', 'Selection', 'Quick', 'Merge',
+                   'Shell', 'Heap', 'Counting', 'Radix', 'Bucket', 'Gnome', 'Comb', 'Cocktail' ]
+    
+    while True:
+        print('\n\n\tSorting Algorithms\n\n')
+    
+        a_length = int(input('Tamanho do array a ser ordenado: '))
+        min = int(input('Menor número possível: '))
+        max = int(input('Maior número possível: '))
+        
+        vet = [random.randint(min, max) for r in xrange(a_length)]
+        
+        print('\nVetor gerado: ')
+        print(vet)
+        
+        print('\nEscolha um algoritmo de Ordenação: ')
+        for i, x in enumerate(algorithms):
+            print(i, ' - ', x)
+        op = input()
+        
+        if op == '0':
+            sort_alg = bubble
+        elif op == '1':
+            sort_alg = insertion
+        elif op == '2':
+            sort_alg = selection
+        elif op == '3':
+            sort_alg = quick
+        elif op == '4':
+            sort_alg = merge
+        elif op == '5':
+            sort_alg = shell
+        elif op == '6':
+            sort_alg = heap
+        elif op == '7':
+            sort_alg = counting
+        elif op == '8':
+            sort_alg = radix
+        elif op == '9':
+            sort_alg = bucket
+        elif op == '10':
+            sort_alg = gnome
+        elif op == '11':
+            sort_alg = comb
+        elif op == '12':
+            sort_alg = cocktail
+        else:
+            print('\nOpção inválida.')
+        
+        print('\nOrdenando pelo método ', algorithms[int(op)], '...')
+        print('\nVetor ordenado: ')
+        
+        ini = time.time()
+        print(sort_alg(vet))
+        fim = time.time()
+        print('\n\nTempo total gasto: ', fim-ini)
+        
+        
+        
+        
+        

src/sort/__pycache__/sort.cpython-35.pyc

@@ -22,6 +22,7 @@ def bubble(nlist):
             if nlist[j] > nlist[j + 1]:
                 nlist[j + 1], nlist[j] = nlist[j], nlist[j + 1] 
                 exchanges = True
+                
     return nlist
 
 def insertion(nlist):
@@ -39,6 +40,7 @@ def insertion(nlist):
             nlist[j + 1] = nlist[j]
             j -= 1
         nlist[j + 1] = key
+        
     return nlist
 
 def selection(nlist):
@@ -53,8 +55,9 @@ def selection(nlist):
         for j in range(i + 1, size):
             if nlist[j] < nlist[lower]:
                 lower = j
-                print(nlist)
+
         nlist[i], nlist[lower] = nlist[lower], nlist[i]
+        
     return nlist
 
 def quick(nlist):
@@ -85,6 +88,7 @@ def merge(nlist):
             result.append(l.pop(0))
 
     result.extend(l + r)
+    
     return result
 
 def shell(nlist):
@@ -123,6 +127,7 @@ def heap(nlist):
     for end in range(size - 1, 0, -1):  
         nlist[end], nlist[0] = nlist[0], nlist[end]
         _max_heap(nlist, 0, end - 1)
+        
     return nlist
 
 def _max_heap(nlist, root, end):
@@ -195,48 +200,107 @@ def radix(aList):
 
     return nlist
 
-import math
-
-DEFAULT_BUCKET_SIZE = 5
-
-def bucket(array, bucketSize=DEFAULT_BUCKET_SIZE):
-    if len(array) == 0:
-        return array
+def bucket(aList, bucketSize=5):
+    nlist = list(aList)
+    size = len(nlist)
+    
+    if size < 2:
+        return nlist
 
-    # Determine minimum and maximum values
-    minValue = array[0]
-    maxValue = array[0]
-    for i in range(1, len(array)):
-        if array[i] < minValue:
-            minValue = array[i]
-        elif array[i] > maxValue:
-            maxValue = array[i]
+    minValue = min(nlist)
+    maxValue = max(nlist)
 
-    # Initialize buckets
     bucketCount = math.floor((maxValue - minValue) / bucketSize) + 1
     buckets = []
+    
     for i in range(0, bucketCount):
         buckets.append([])
 
-    # Distribute input array values into buckets
-    for i in range(0, len(array)):
-        buckets[math.floor((array[i] - minValue) / bucketSize)].append(array[i])
+    for i in range(0, size):
+        buckets[math.floor((nlist[i] - minValue) / bucketSize)].append(nlist[i])
 
-    # Sort buckets and place back into input array
-    array = []
+    nlist = []
     for i in range(0, len(buckets)):
-        insertion(buckets[i])
+        buckets[i] = insertion(buckets[i])
         for j in range(0, len(buckets[i])):
-            array.append(buckets[i][j])
+            nlist.append(buckets[i][j])
 
-    return array
+    return nlist
 
+def gnome(aList):
+    nlist = list(aList)
+    size = len(nlist)
 
+    if size < 2:
+        return nlist
 
+    pivot = 0
+    nlist_length = len(nlist) 
+    while pivot < nlist_length - 1:
+        if nlist[pivot] > nlist[pivot + 1]:
+            nlist[pivot + 1], nlist[pivot] = nlist[pivot], nlist[pivot + 1]
+            if pivot > 0:
+                pivot -= 2
+        pivot += 1
+        
+    return nlist
 
+def comb(aList):
+    nlist = list(aList)
+    size = len(nlist)
+    
+    if size < 2:
+        return nlist
 
+    gap = size
+    swaps = True
 
+    while gap > 1 or swaps:
+        gap = max(1, int(gap / 1.25)) # Minimun gap is 1
+        swaps = False
+        
+        for i in range(size - gap):
+            j = i + gap
 
+            if nlist[i] > nlist[j]:
+                nlist[i], nlist[j] = nlist[j], nlist[i]
+                swaps = True
+            print(nlist)
+    return nlist
+    
+def cocktail(aList):
+    nlist = list(aList)
+    size = len(nlist)
+    
+    if size < 2:
+        return nlist
+    
+    swapped = True
+    i = 0
+    j = size - 1
+    
+    while i < j and swapped:
+        for k in range(i, j):
+            if nlist[k] > nlist[k + 1]:
+                nlist[k], nlist[k + 1] = nlist[k + 1], nlist[k]
+                swapped = True
+        j -= 1
+        
+        if swapped:
+            swapped = False
+            for k in range(j, i, -1):
+                if nlist[k] < nlist[k - 1]:
+                    nlist[k], nlist[k - 1] = nlist[k - 1], nlist[k]
+                    swapped = True
+        
+        i += 1
+        
+        if not swapped:
+            return nlist
+            
+    
+    
+