Devoirs à bulles

En classe, nous faisons des algorithmes de tri et, bien que je les comprenne bien lorsque j'en parle et que j'écris du pseudocode, j'ai des problèmes pour écrire du code réel pour eux.

Voici ma tentative en Python:

mylist = [12, 5, 13, 8, 9, 65]

def bubble(badList):
    length = len(badList) - 1
    unsorted = True

    while unsorted:
        for element in range(0,length):
            unsorted = False
            if badList[element] > badList[element + 1]:
                hold = badList[element + 1]
                badList[element + 1] = badList[element]
                badList[element] = hold
                print badList
            else:
                unsorted = True

print bubble(mylist)

Maintenant, cela (pour autant que je sache) trie correctement, mais une fois terminé, il se boucle indéfiniment.

Comment ce code peut-il être corrigé pour que la fonction se termine correctement et trie correctement une liste de toute taille (raisonnable)?

PS Je sais que je ne devrais pas vraiment avoir d'impressions dans une fonction et que je devrais avoir un retour, mais je ne l'ai juste pas encore fait car mon code ne fonctionne pas encore vraiment.

Pour expliquer pourquoi votre script ne fonctionne pas pour le moment, je renommerai la variable unsorteden sorted.

Au début, votre liste n'est pas encore triée. Bien sûr, nous nous sommes mis sortedà False.

Dès que nous démarrons la whileboucle, nous supposons que la liste est déjà triée. L'idée est la suivante: dès que l'on trouve deux éléments qui ne sont pas dans le bon ordre, on se sortedremet False. sortedne restera True que s'il n'y avait pas d'éléments dans le mauvais ordre .

sorted = False  # We haven't started sorting yet

while not sorted:
    sorted = True  # Assume the list is now sorted
    for element in range(0, length):
        if badList[element] > badList[element + 1]:
            sorted = False  # We found two elements in the wrong order
            hold = badList[element + 1]
            badList[element + 1] = badList[element]
            badList[element] = hold
    # We went through the whole list. At this point, if there were no elements
    # in the wrong order, sorted is still True. Otherwise, it's false, and the
    # while loop executes again.

Il existe également de petits problèmes mineurs qui aideraient le code à être plus efficace ou plus lisible.

• Dans la forboucle, vous utilisez la variable element. Techniquement, ce elementn'est pas un élément; c'est un nombre représentant un index de liste. De plus, c'est assez long. Dans ces cas, utilisez simplement un nom de variable temporaire, comme ipour "index".

  for i in range(0, length):

• La rangecommande peut également prendre un seul argument (nommé stop). Dans ce cas, vous obtenez une liste de tous les entiers de 0 à cet argument.

  for i in range(length):

• Le Guide de style Python recommande que les variables soient nommées en minuscules avec des traits de soulignement. C'est un petit pinaillage pour un petit script comme celui-ci; il s'agit davantage de vous habituer à ce à quoi ressemble le plus souvent le code Python.

  def bubble(bad_list):

• Pour permuter les valeurs de deux variables, écrivez-les sous forme d'affectation de tuple. Le côté droit est évalué comme un tuple (disons, (badList[i+1], badList[i])est (3, 5)) puis est assigné aux deux variables du côté gauche ( (badList[i], badList[i+1])).

  bad_list[i], bad_list[i+1] = bad_list[i+1], bad_list[i]

Mettez tout cela ensemble, et vous obtenez ceci:

my_list = [12, 5, 13, 8, 9, 65]

def bubble(bad_list):
    length = len(bad_list) - 1
    sorted = False

    while not sorted:
        sorted = True
        for i in range(length):
            if bad_list[i] > bad_list[i+1]:
                sorted = False
                bad_list[i], bad_list[i+1] = bad_list[i+1], bad_list[i]

bubble(my_list)
print my_list

(Au fait, j'ai également supprimé votre déclaration imprimée.)

Le but du tri à bulles est de déplacer les objets les plus lourds en bas à chaque tour, tout en déplaçant les objets les plus légers vers le haut. Dans la boucle interne, où vous comparez les éléments, vous n'avez pas à parcourir toute la liste à chaque tour . Le plus lourd est déjà placé en dernier. La variable permutée est une vérification supplémentaire afin que nous puissions marquer que la liste est maintenant triée et éviter de continuer avec des calculs inutiles.

def bubble(badList):
    length = len(badList)
    for i in range(0,length):
        swapped = False
        for element in range(0, length-i-1):
            if badList[element] > badList[element + 1]:
                hold = badList[element + 1]
                badList[element + 1] = badList[element]
                badList[element] = hold
                swapped = True
        if not swapped: break

    return badList

Votre version 1, corrigée:

def bubble(badList):
    length = len(badList) - 1
    unsorted = True
    while unsorted:
        unsorted = False
        for element in range(0,length):
            #unsorted = False
            if badList[element] > badList[element + 1]:
                 hold = badList[element + 1]
                 badList[element + 1] = badList[element]
                 badList[element] = hold
                 unsorted = True
                 #print badList
             #else:
                 #unsorted = True

     return badList

C'est ce qui se passe lorsque vous utilisez un nom de variable de signification négative, vous devez inverser leurs valeurs. Ce qui suit serait plus facile à comprendre:

sorted = False
while not sorted:
    ...

En revanche, la logique de l'algorithme est un peu décalée. Vous devez vérifier si deux éléments ont été échangés pendant la boucle for. Voici comment je l'écrirais:

def bubble(values):
    length = len(values) - 1
    sorted = False
    while not sorted:
        sorted = True
        for element in range(0,length):
            if values[element] > values[element + 1]:
                 hold = values[element + 1]
                 values[element + 1] = values[element]
                 values[element] = hold
                 sorted = False
    return values

Votre utilisation de la variable Unsorted est incorrecte; vous voulez avoir une variable qui vous indique si vous avez permuté deux éléments; si vous avez fait cela, vous pouvez quitter votre boucle, sinon vous devez recommencer. Pour corriger ce que vous avez ici, mettez simplement le "unsorted = false" dans le corps de votre cas if; supprimez votre autre cas; et mettez "unsorted = true avant votre forboucle.

def bubble_sort(l):
    for passes_left in range(len(l)-1, 0, -1):
        for index in range(passes_left):
            if l[index] < l[index + 1]:
               l[index], l[index + 1] = l[index + 1], l[index]
    return l

#Une fonction très simple, peut être optimisée (évidemment) en diminuant l'espace problème du 2ème tableau. Mais même complexité O (n ^ 2).

def bubble(arr):
    l = len(arr)        
    for a in range(l):
        for b in range(l-1):
            if (arr[a] < arr[b]):
            arr[a], arr[b] = arr[b], arr[a]
    return arr 

Vous avez quelques erreurs là-dedans. Le premier est de longueur, et le second est dans votre utilisation de non trié (comme indiqué par McWafflestix). Vous voudrez probablement aussi renvoyer la liste si vous allez l'imprimer:

mylist = [12, 5, 13, 8, 9, 65]

def bubble(badList):
    length = len(badList) - 2
    unsorted = True

    while unsorted:
        for element in range(0,length):
            unsorted = False

            if badList[element] > badList[element + 1]:
                hold = badList[element + 1]
                badList[element + 1] = badList[element]
                badList[element] = hold
                print badList
                unsorted = True

    return badList

print bubble(mylist)

eta: Vous avez raison, ce qui précède est un buggy comme l'enfer. Mon mal de ne pas avoir testé d'autres exemples.

def bubble2(badList):
    swapped = True
    length = len(badList) - 2

    while swapped:
        swapped = False
        for i in range(0, length):
            if badList[i] > badList[i + 1]:

                # swap
                hold = badList[i + 1]
                badList[i + 1] = badList[i]
                badList[i] = hold

                swapped = True

    return badList

Je suis un nouveau débutant, j'ai commencé à lire sur Python hier. Inspiré par votre exemple, j'ai créé quelque chose peut-être plus dans le style des 80 cravates, mais néanmoins cela fonctionne un peu

lista1 = [12, 5, 13, 8, 9, 65]

i=0
while i < len(lista1)-1:
    if lista1[i] > lista1[i+1]:
        x = lista1[i]
        lista1[i] = lista1[i+1]
        lista1[i+1] = x
        i=0
        continue
    else:
        i+=1

print(lista1)

Le problème avec l'algorithme d'origine est que si vous aviez un nombre inférieur plus loin dans la liste, il ne l'amènerait pas à la bonne position triée. Le programme doit revenir au début à chaque fois pour s'assurer que les nombres sont triés tout au long.

J'ai simplifié le code et cela fonctionnera désormais pour n'importe quelle liste de nombres quelle que soit la liste et même s'il y a des nombres qui se répètent. Voici le code

mylist = [9, 8, 5, 4, 12, 1, 7, 5, 2]
print mylist

def bubble(badList):
    length = len(badList) - 1
    element = 0
    while element < length:
        if badList[element] > badList[element + 1]:
            hold = badList[element + 1]
            badList[element + 1] = badList[element]
            badList[element] = hold
            element = 0
            print badList
        else:
            element = element + 1

print bubble(mylist)

def bubble_sort(l):
    exchanged = True
    iteration = 0
    n = len(l)

    while(exchanged):
        iteration += 1
        exchanged = False

        # Move the largest element to the end of the list
        for i in range(n-1):
            if l[i] > l[i+1]:
                exchanged = True
                l[i], l[i+1] = l[i+1], l[i]
        n -= 1   # Largest element already towards the end

    print 'Iterations: %s' %(iteration)
    return l

def bubbleSort(alist):
if len(alist) <= 1:
    return alist
for i in range(0,len(alist)):
   print "i is :%d",i
   for j in range(0,i):
      print "j is:%d",j
      print "alist[i] is :%d, alist[j] is :%d"%(alist[i],alist[j])
      if alist[i] > alist[j]:
         alist[i],alist[j] = alist[j],alist[i]
return alist

alist = [54,26,93,17,77,31,44,55,20, -23, -34,16,11,11,11]

imprimer bubbleSort (alist)

def bubble_sort(a):
    t = 0
    sorted = False # sorted = False because we have not began to sort
    while not sorted:
    sorted = True # Assume sorted = True first, it will switch only there is any change
        for key in range(1,len(a)):
            if a[key-1] > a[key]:
                sorted = False
                t = a[key-1]; a[key-1] = a[key]; a[key] = t;
    print a

Un exemple plus simple:

a = len(alist)-1
while a > 0:
    for b in range(0,a):
        #compare with the adjacent element
        if alist[b]>=alist[b+1]:
            #swap both elements
            alist[b], alist[b+1] = alist[b+1], alist[b]
    a-=1

Cela prend simplement les éléments de 0 à a (en gros, tous les éléments non triés de ce tour) et le compare à son élément adjacent, et effectue un échange s'il est supérieur à son élément adjacent. À la fin du tour, le dernier élément est trié et le processus s'exécute à nouveau sans lui, jusqu'à ce que tous les éléments aient été triés.

Il n'est pas nécessaire de définir une condition, qu'elle sortsoit vraie ou non.

Notez que cet algorithme prend en considération la position des nombres uniquement lors de l'échange, donc les nombres répétés ne l'affecteront pas.

PS. Je sais que cela fait très longtemps que cette question a été publiée, mais je voulais juste partager cette idée.

arr = [5,4,3,1,6,8,10,9] # array not sorted

for i in range(len(arr)):
    for j in range(i, len(arr)):
        if(arr[i] > arr[j]):
            arr[i], arr[j] = arr[j], arr[i]

            print (arr)

def bubble_sort(li):
    l = len(li)
    tmp = None
    sorted_l = sorted(li)
    while (li != sorted_l):
        for ele in range(0,l-1):
            if li[ele] > li[ele+1]:
                tmp = li[ele+1]
                li[ele+1] = li [ele]
                li[ele] = tmp
    return li

def bubbleSort ( arr ):
    swapped = True 
    length = len ( arr )
    j = 0

    while swapped:
        swapped = False
        j += 1 
        for i in range ( length  - j ):
            if arr [ i ] > arr [ i + 1 ]:
                # swap
                tmp = arr [ i ]
                arr [ i ] = arr [ i + 1]
                arr [ i + 1 ] = tmp 

                swapped = True

if __name__ == '__main__':
    # test list
    a = [ 67, 45, 39, -1, -5, -44 ];

    print ( a )
    bubbleSort ( a )
    print ( a )

def bubblesort(array):
    for i in range(len(array)-1):
        for j in range(len(array)-1-i):
            if array[j] > array[j+1]:
                array[j], array[j+1] = array[j+1], array[j]
    return(array)

print(bubblesort([3,1,6,2,5,4]))

J'envisage d'ajouter ma solution car chaque solution ici est d'avoir

1. plus de temps
2. une plus grande complexité de l'espace
3. ou faire trop d'opérations

alors est devrait être

Alors, voici ma solution:

def countInversions(arr):
    count = 0
    n = len(arr)
    for i in range(n):
        _count = count
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                count += 1
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
        if _count == count:
            break
    return count

Si quelqu'un est intéressé par une implémentation plus courte utilisant une compréhension de liste:

def bubble_sort(lst: list) -> None:
    [swap_items(lst, i, i+1) for left in range(len(lst)-1, 0, -1) for i in range(left) if lst[i] > lst[i+1]]


def swap_items(lst: list, pos1: int, pos2: int) -> None:
    lst[pos1], lst[pos2] = lst[pos2], lst[pos1]

Voici une variante différente du tri à bulles sans forboucle. Fondamentalement, vous considérez le lastIndexde arrayet lentement decrementingjusqu'à ce qu'il soit le premier index du tableau.

Le algorithmcontinuera à se déplacer dans le tableau comme ceci jusqu'à ce qu'une passe entière soit effectuée sans qu'aucune ne swapsse produise.

La bulle est en quelque sorte en Quadratic Time: O(n²)matière de performances.

class BubbleSort: 
  def __init__(self, arr):
    self.arr = arr;

  def bubbleSort(self):
    count = 0;
    lastIndex = len(self.arr) - 1;
    
    while(count < lastIndex):
      if(self.arr[count] > self.arr[count + 1]):
        self.swap(count)  
      count = count + 1;

      if(count == lastIndex):
        count = 0;
        lastIndex = lastIndex - 1;   

  def swap(self, count):
    temp = self.arr[count];
    self.arr[count] = self.arr[count + 1];
    self.arr[count + 1] = temp;
    
arr = [9, 1, 5, 3, 8, 2]
p1 = BubbleSort(arr)

print(p1.bubbleSort())

Les réponses fournies par the-fury et Martin Cote ont résolu le problème de la boucle infinie, mais mon code ne fonctionnait toujours pas correctement (pour une liste plus grande, il ne trierait pas correctement.). J'ai fini par abandonner la unsortedvariable et j'ai utilisé un compteur à la place.

def bubble(badList):
    length = len(badList) - 1
    n = 0
    while n < len(badList):
        for element in range(0,length):
            if badList[element] > badList[element + 1]:
                hold = badList[element + 1]
                badList[element + 1] = badList[element]
                badList[element] = hold
                n = 0
            else:
                n += 1
    return badList

if __name__ == '__main__':
    mylist = [90, 10, 2, 76, 17, 66, 57, 23, 57, 99]
    print bubble(mylist)

Si quelqu'un pouvait fournir des conseils sur la façon d'améliorer mon code dans les commentaires, ce serait très apprécié.

Essaye ça

a = int(input("Enter Limit"))


val = []

for z in range(0,a):
    b = int(input("Enter Number in List"))
    val.append(b)


for y in range(0,len(val)):
   for x in range(0,len(val)-1):
       if val[x]>val[x+1]:
           t = val[x]
           val[x] = val[x+1]
           val[x+1] = t

print(val)

idk si cela peut vous aider après 9 ans ... c'est un simple programme de tri à bulles

    l=[1,6,3,7,5,9,8,2,4,10]

    for i in range(1,len(l)):
        for j in range (i+1,len(l)):
            if l[i]>l[j]:
                l[i],l[j]=l[j],l[i]

def merge_bubble(arr):
    k = len(arr)
    while k>2:
        for i in range(0,k-1):
            for j in range(0,k-1):
                if arr[j] > arr[j+1]:
                    arr[j],arr[j+1] = arr[j+1],arr[j]

        return arr
        break
    else:
        if arr[0] > arr[1]:
            arr[0],arr[1] = arr[1],arr[0]
        return arr 

def bubble_sort(l):
    for i in range(len(l) -1):
        for j in range(len(l)-i-1):
            if l[j] > l[j+1]:
                l[j],l[j+1] = l[j+1], l[j]
    return l

def bubble_sorted(arr:list):
    while True:
        for i in range(0,len(arr)-1):
            count = 0
            if arr[i] > arr[i+1]:
                count += 1
                arr[i], arr[i+1] = arr[i+1], arr[i]
        if count == 0:
            break
    return arr
arr = [30,20,80,40,50,10,60,70,90]
print(bubble_sorted(arr))
#[20, 30, 40, 50, 10, 60, 70, 80, 90]

def bubbleSort(a): def swap(x, y): temp = a[x] a[x] = a[y] a[y] = temp #outer loop for j in range(len(a)): #slicing to the center, inner loop, python style for i in range(j, len(a) - j):
#find the min index and swap if a[i] < a[j]: swap(j, i) #find the max index and swap if a[i] > a[len(a) - j - 1]: swap(len(a) - j - 1, i) return a